# Auction.com $1💰 URL Search | Keyword Filtering | Rich Output (`abotapi/auction-com-scraper`) Actor

From $1/1K. Extract foreclosure, REO, short-sale, and auction listings from Auction.com in minutes. Search by location and property filters or paste any Auction.com URL. Get 45+ structured fields, including auction dates, bids, estimated values, occupancy status, coordinates, and photos.

- **URL**: https://apify.com/abotapi/auction-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 8 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Auction.com Property Scraper

Collect foreclosure, bank-owned (REO), short-sale and private-seller auction listings from Auction.com in minutes. Search by state, city, ZIP, property type, asset type, beds, baths, square footage and price, or paste any Auction.com search URL. Every listing comes back with 45+ structured fields including auction dates, starting bids, estimated value, occupancy, coordinates and photos.

### Why this scraper

- **Two input modes.** Build a query from structured filters, or paste one or more Auction.com URLs. Multiple URLs are supported in a single run.
- **45+ fields per listing**, well past the typical 30-field offering: auction window, starting bid, estimated resale value, occupancy status, financing and buyer-premium flags, beds/baths/sqft, lot size, year built, latitude/longitude, photos and more.
- **Walks the whole catalogue by default.** `maxPages` defaults to `0` (unlimited) — the run walks every result page using offset pagination, stopping on its own once the site's reported total is reached, a page comes back empty, or a page returns no new listings (repeat-page guard). There is no artificial page-number ceiling; the only cap you need is `maxListings`.
- **`maxListings` is the sole cap on volume** (default `20`, so a first run is small and fast; set `0` for unlimited on paid plans).
- **Resumable runs.** Set `resumeFromRunId` to a previous run or dataset id to collect only the listings that run doesn't already have (a delta) — combine both datasets for the full set. Long unlimited runs also checkpoint their progress to the key-value store, so an Apify platform migration or a Resurrect of a failed run picks up where it left off instead of starting over.
- **Incremental & dedup mode for scheduled runs.** Turn on `incrementalMode` and run the same search daily — the actor remembers the previous run itself and returns only `NEW`, `UPDATED`, and `REAPPEARED` listings by default; unchanged listings are suppressed (and not billed). See [Resume & recurring updates](#resume--recurring-updates).
- **Optional full-detail mode.** Turn on `fetchDetails` for complete auction terms, financing preference, deposit and earnest-money minimums, leaseback terms and days-to-close per listing (plus any extra media the listing exposes).
- **Fast and lightweight.** Reads structured data directly, so runs finish quickly and cheaply on the default Apify datacenter proxy. No residential proxy required.
- **Multi-state and multi-URL** in a single run, with automatic de-duplication.

### Data you get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| listingId | `00000001` |
| url | `https://www.auction.com/details/123-sample-st-city-st-00000001` |
| address | `123 Sample St, Springfield, ST 00000, Sample County` |
| city / state / zip | `Springfield` / `ST` / `00000` |
| county | `Sample County` |
| latitude / longitude | `38.0000` / `-90.0000` |
| propertyTypeGroup | `SINGLE_FAMILY` |
| assetType | `BANK_OWNED` |
| listingStatusGroup | `ACTIVE` |
| bedrooms / bathrooms | `3` / `2` |
| squareFootage | `1800` |
| lotSize | `0.25` |
| yearBuilt | `1995` |
| startingBid | `150000` |
| estimatedValue | `225000` (property value estimate) |
| rentalEstimate | `1800` (monthly rent estimate) |
| auctionType | `ONLINE` |
| auctionStartDate | `2026-01-01T00:00:00Z` |
| auctionEndDate | `2026-01-03T00:00:00Z` |
| occupancyStatus | `VACANT` |
| financingAvailable | `true` |
| buyerPremiumAvailable | `false` |
| isRemoteBidEnabled | `true` |
| primaryPhoto | `https://adc-tenbox-prod.imgix.net/resi/property_image/0000000-1-G.v4.jpg` |
| photoCount | `12` |
| financePreference (detail mode) | `CASH` |
| daysToClose (detail mode) | `30` |
| earnestMoneyDepositMinimum (detail mode) | `5000` |

Plus marketing tags, open houses, trustee-sale flags, valuation bands, and the complete source record under `raw` for any field not surfaced flat.

### How to use

Search a single state for active listings:

```json
{
  "mode": "search",
  "states": ["CA"],
  "listingStatus": "active",
  "maxListings": 200
}
```

Walk an entire state's active-listing catalogue with no page limit (bounded only by the site's own total and `maxListings`):

```json
{
  "mode": "search",
  "states": ["CA"],
  "listingStatus": "active",
  "maxListings": 0
}
```

Resume a previous run, collecting only listings it doesn't already have:

```json
{
  "mode": "search",
  "states": ["CA"],
  "maxListings": 0,
  "resumeFromRunId": "<a previous run id or dataset id from this account>"
}
```

Search with filters (condos and townhouses, 3+ beds, under 300k, in two states):

```json
{
  "mode": "search",
  "states": ["TX", "FL"],
  "propertyTypes": ["condos-townhouses"],
  "minBeds": 3,
  "maxPrice": 300000,
  "sortBy": "price-asc",
  "maxListings": 500
}
```

Bank-owned, online auctions, with full details:

```json
{
  "mode": "search",
  "states": ["GA"],
  "assetTypes": ["bank-owned"],
  "auctionFormats": ["online"],
  "fetchDetails": true,
  "maxListings": 100
}
```

Paste Auction.com URLs (apply filters on the website, then copy the URL):

```json
{
  "mode": "url",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt/single-family_pt",
    "https://www.auction.com/residential/TX/active_lt"
  ],
  "maxPages": 3
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | string | `search` | `search` (use filters) or `url` (paste links) |
| states | array | `["CA"]` | Two-letter US state codes |
| city | string | | City name to narrow the search |
| zipCodes | array | | List of 5-digit ZIP codes |
| keyword | string | | Free-text search across street, city, state, ZIP |
| listingStatus | string | `active` | `active` or `sold` |
| propertyTypes | array | | `single-family`, `condos-townhouses`, `multi-family`, `land` |
| assetTypes | array | | `bank-owned`, `foreclosures`, `short-sales`, `private-seller` |
| auctionFormats | array | | `online`, `in-person`, `remote-bid` |
| minBeds / maxBeds | integer | | Bedroom range |
| minBaths | integer | | Minimum bathrooms |
| minSqft / maxSqft | integer | | Living area range in square feet |
| minPrice / maxPrice | integer | | Starting bid range in USD |
| sortBy | string | `default` | Sort order |
| urls | array | | Auction.com URLs (URL mode) |
| fetchDetails | boolean | `false` | Fetch the full gallery and terms per listing |
| maxPages | integer | `0` | Optional bound on pages walked per search/URL (100 listings per page). `0` = walk the whole catalogue: stops on its own at the site's reported total, an empty page, or a page with no new listings — never an artificial page cap. Does not cap listing count; use `maxListings` for that. |
| maxListings | integer | `20` | The sole cap on total listings collected (max 1,000,000). `0` means unlimited. |
| resumeFromRunId | string | | Optional id of a previous run (or dataset) of this actor. Listings already in that dataset are skipped, so this run returns only new listings (a delta). For recurring daily monitoring of the same search, use `incrementalMode` instead. |
| incrementalMode | boolean | `false` | Turn on for daily/recurring monitoring. Returns only `NEW`/`UPDATED`/`REAPPEARED` listings after the first run; unchanged listings are suppressed and not billed unless `emitUnchanged` is on. |
| stateKey | string | | Optional. Name a monitoring campaign explicitly, or share state across differently-configured runs. Leave empty to derive a key automatically from the search/filter setup. |
| emitUnchanged | boolean | `false` | Also return listings unchanged since the last run, marked `UNCHANGED` (extra billed rows). |
| emitExpired | boolean | `false` | Also return listings no longer found, marked `EXPIRED`. Only produced once a run fully scans the tracked search (not capped, not resumed). |
| proxy | object | Apify datacenter | Proxy configuration |

### Resume & recurring updates

There are two different things here — pick the one that matches what you're doing:

| Need | Use |
| --- | --- |
| A run stopped and should continue | `resumeFromRunId` / automatic checkpoint recovery |
| Run the same search every day and receive only changes | `incrementalMode` |
| Keep separate daily campaigns for similar searches | distinct `stateKey` values |
| Run a normal full snapshot | leave both off |

**Resume** (`resumeFromRunId`) continues one specific interrupted or previous large run: paste a run id or dataset id and this run skips listings already collected there, returning only the remaining new listings. An automatic same-run checkpoint also protects against platform migrations/Resurrects without any input needed.

**Incremental mode** (`incrementalMode`) is for a schedule (for example, daily): the actor remembers the previous run of the *same* search by itself, so you never paste a run id. The first run returns everything as `NEW`. Later runs return only `NEW`, `UPDATED`, and `REAPPEARED` listings by default — duplicates and unchanged listings are suppressed (and not charged). Turn on `emitUnchanged` or `emitExpired` only when you also want those rows returned (and billed for). State is isolated automatically per mode/states/city/zipCodes/keyword/listingStatus/propertyTypes/assetTypes/auctionFormats/beds/baths/sqft/price/sortBy/urls/fetchDetails setup — `maxPages`/`maxListings` are caps, not filters, and deliberately do **not** affect the state key, so raising your cap on a later run does not re-bill the whole catalogue. Set `stateKey` to name or deliberately share a monitoring campaign. `EXPIRED` is only synthesized once a run fully scans every search/URL target (not capped by Max listings/Max pages, not a Resume run, not a checkpoint-interrupted run).

When `incrementalMode` is on, every returned record also carries:

| Field | Description |
|---|---|
| `changeType` | `NEW` | `UPDATED` | `UNCHANGED` | `REAPPEARED` | `EXPIRED` |
| `changedFields` | Top-level fields that changed since last seen; non-empty only for `UPDATED` |
| `firstSeenAt` | When this listing was first observed by this monitoring campaign |
| `lastSeenAt` | When this listing was last observed |

**What drives change detection:** every flat top-level field (address, status, price/bid, auction dates, occupancy, etc.) except `scrapedAt`, which is stamped fresh on every push and excluded so it never fakes an `UPDATED`. The verbatim `raw`/`detailRaw` passthrough fields are also excluded from the diff — the GraphQL selection this actor requests (`src/dsl.py`) is a fixed field list, not a wildcard, and every field it returns is already mirrored onto a flat field above, so `raw`/`detailRaw` would only duplicate the same signal while roughly tripling the incremental-state footprint. They are always still **returned** in the output; a real price, bid, auction-date, or status change still triggers `UPDATED` as usual.

Scheduled-run example — same search, run daily:

Day 1 (first run ever for this search):

```json
{ "mode": "search", "states": ["CA"], "incrementalMode": true }
```

→ every listing comes back with `"changeType": "NEW"`.

Day 2 (the schedule fires again, identical input):

```json
{ "mode": "search", "states": ["CA"], "incrementalMode": true }
```

→ listings whose price/status/auction date/etc. changed come back as `"changeType": "UPDATED"` with `changedFields` listing what changed, brand-new listings come back as `"changeType": "NEW"` — and listings that are still there, unchanged, are **not** returned at all (suppressed, not charged) unless `emitUnchanged` is on.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "listingId": "00000001",
  "url": "https://www.auction.com/details/123-sample-st-springfield-st-00000001",
  "address": "123 Sample St, Springfield, ST 00000, Sample County",
  "city": "Springfield",
  "state": "ST",
  "zip": "00000",
  "county": "Sample County",
  "latitude": 38.0000,
  "longitude": -90.0000,
  "propertyTypeGroup": "SINGLE_FAMILY",
  "assetType": "BANK_OWNED",
  "productType": "REO",
  "occupancyStatus": "VACANT",
  "listingStatusGroup": "ACTIVE",
  "bedrooms": 3,
  "bathrooms": 2,
  "squareFootage": 1800,
  "lotSize": 0.25,
  "yearBuilt": 1995,
  "startingBid": 150000,
  "estimatedValue": 225000,
  "estimatedValueLow": 210000,
  "estimatedValueHigh": 240000,
  "auctionType": "ONLINE",
  "auctionStartDate": "2026-01-01T00:00:00Z",
  "auctionEndDate": "2026-01-03T00:00:00Z",
  "financingAvailable": true,
  "buyerPremiumAvailable": false,
  "isRemoteBidEnabled": true,
  "primaryPhoto": "https://adc-tenbox-prod.imgix.net/resi/property_image/0000000-1-G.v4.jpg",
  "photoCount": 12,
  "marketingTags": [],
  "scrapedAt": "2026-01-01T00:00:00Z"
}
```

### Plan requirement

This scraper runs on the default Apify datacenter proxy, so it works on the free plan for small runs. For large runs and faster throughput, any paid plan gives more compute and proxy bandwidth. Residential proxy is optional and not required for this source. If you do select residential, the run rotates a US/CA exit pool (a fresh session per attempt, and any explicit country pin is respected) and automatically fails over to a backup connection pool after repeated failures, so a single flagged exit IP will not stall the run. Free accounts should keep `maxListings` modest; paid accounts can set it to 0 for unlimited.

### Verification

URL mode and the keyword, city and state filters re-verified against the live listings backend on 2026-08-30.

# Actor input Schema

## `mode` (type: `string`):

How to find listings. 'search' builds the query from the filter fields below. 'url' takes one or more Auction.com search URLs you paste.

## `states` (type: `array`):

Two-letter US state codes to search, e.g. CA, TX, FL. Leave empty to search nationwide.

## `city` (type: `string`):

Optional city name to narrow the search, e.g. Los Angeles. Combine with a single state for best results.

## `zipCodes` (type: `array`):

Optional list of 5-digit ZIP codes to narrow the search.

## `keyword` (type: `string`):

Optional free-text search across street, city, state and ZIP, e.g. 'Main St' or '90210'.

## `listingStatus` (type: `string`):

Active listings open for bidding, or sold/closed listings.

## `propertyTypes` (type: `array`):

Filter by property category. Leave empty for all.

## `assetTypes` (type: `array`):

Filter by distressed-asset category. Leave empty for all.

## `auctionFormats` (type: `array`):

Filter by how the auction is run. Leave empty for all.

## `minBeds` (type: `integer`):

Minimum number of bedrooms.

## `maxBeds` (type: `integer`):

Maximum number of bedrooms.

## `minBaths` (type: `integer`):

Minimum number of bathrooms.

## `minSqft` (type: `integer`):

Minimum living area in square feet.

## `maxSqft` (type: `integer`):

Maximum living area in square feet.

## `minPrice` (type: `integer`):

Minimum starting bid in USD.

## `maxPrice` (type: `integer`):

Maximum starting bid in USD.

## `sortBy` (type: `string`):

Result ordering.

## `urls` (type: `array`):

One or more Auction.com search URLs. Apply filters on the website, copy the URL, and paste it here. Multiple URLs supported; pagination walks forward from the page in each URL. Search-mode filter fields above are ignored.

## `fetchDetails` (type: `boolean`):

Make an extra request per listing for the full photo gallery, complete auction terms, deposit/financing details and documents. Slower and billed per detail page; off by default.

## `maxPages` (type: `integer`):

Optional bound on result pages walked per search/URL (100 listings per page). Use 0 to walk the whole catalogue: the run stops on its own once the site's reported total is reached, a page comes back empty, or a page returns no new listings. This does NOT cap the number of listings; use Max listings for that.

## `maxListings` (type: `integer`):

Hard cap on total listings collected. 0 means unlimited (paid plans).

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Listings already in that dataset are skipped, so this run returns only NEW listings (a delta). Combine both runs' datasets for the full set. Max listings then counts only the new listings. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching listings as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED listings. Turn on "Emit unchanged" or "Emit expired" only when you also want those listings returned (and billed). State is kept separately for each distinct search/filter setup (or by State key below).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from your search/filter settings — different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return listings that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return listings that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search — not when Max listings or Max pages capped it, or when Resume was used. This returns — and bills — extra synthetic rows.

## `proxy` (type: `object`):

Proxy configuration. Apify datacenter (the default) works well for this source; no residential proxy required.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "states": [
    "CA"
  ],
  "listingStatus": "active",
  "sortBy": "default",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt"
  ],
  "fetchDetails": false,
  "maxPages": 0,
  "maxListings": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "states": [
        "CA"
    ],
    "listingStatus": "active",
    "sortBy": "default",
    "urls": [
        "https://www.auction.com/residential/CA/active_lt"
    ],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/auction-com-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "states": ["CA"],
    "listingStatus": "active",
    "sortBy": "default",
    "urls": ["https://www.auction.com/residential/CA/active_lt"],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/auction-com-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "states": [
    "CA"
  ],
  "listingStatus": "active",
  "sortBy": "default",
  "urls": [
    "https://www.auction.com/residential/CA/active_lt"
  ],
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/auction-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/auction-com-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GF5lScACE4b4uNnsP/builds/2AMFmkticeSo4erhO/openapi.json