# Redfin Scraper — Real-Estate Listings & Sold Data (`freshactors/redfin-scraper`) Actor

Reliable, always-fresh Redfin listings: price, beds/baths, sqft, address, lat/long, MLS ID, and more. Paste a Redfin city/zip URL. By FreshActors.

- **URL**: https://apify.com/freshactors/redfin-scraper.md
- **Developed by:** [Freshactors](https://apify.com/freshactors) (community)
- **Categories:** Developer tools, Real estate, E-commerce
- **Features:** Limited permissions
- **Stats:** 8 total users, 2 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.98 / 1,000 listing fetcheds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Redfin (US Real Estate) Scraper — Listings, Sold Data & Property API

Scrape **Redfin (US real estate)** listings into clean, structured JSON — price, beds, baths, square footage, address, lat/long, MLS ID, property type, days-on-market and more — straight from a Redfin city or ZIP URL. No account, no login, no API key.

![Redfin Scraper example output — 28 fields per listing](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/redfin-screenshot.png)

> ✅ **Last verified working: 2026-11-11.** Monitored by an automated daily canary. When Redfin changes something, we patch fast and log it in the changelog below.

***

### Why this Redfin (US real estate) scraper

Most Redfin scrapers on the store are abandoned — stale code, a handful of users, low ratings — and they break the moment Redfin tweaks its internal data API. This one is **maintained, monitored, and built to stay working**:

- **A daily canary runs the actor against live Redfin** and alerts us the moment a field drifts or a block pattern changes. That's the "always-fresh" promise — and why the "Last verified working" badge above is a real date, not marketing.
- **Block-resistant by design.** Redfin's GIS data API returns a "Success" envelope *even when it's bot-blocked*, which is how naive scrapers silently return zero rows. This actor distinguishes a genuine zero-result from a soft block and **retries with backoff + IP rotation** instead of handing you an empty dataset.
- **Paste-a-URL simplicity.** Give it a Redfin city, county or neighborhood URL — the region is parsed straight from the URL. No hunting for internal Redfin region IDs. (ZIP codes depend on a Redfin page that is currently behind an automated-traffic check — see the FAQ.)
- **Stable, versioned output** (`_schemaVersion`). Fields don't silently disappear between runs; schema changes are logged.
- **Fast patches.** Open an issue and it gets answered. Reliability is the entire product.

If you've been burned by a "Redfin API" actor that returns nothing on a Monday morning, this is the fix.

### What data you get

Each row is one property listing. Real fields emitted by the actor:

| Field | Type | Description |
|---|---|---|
| `listingId` | number | Redfin internal listing ID |
| `propertyId` | number | Redfin internal property ID |
| `mlsId` | string | MLS number for the listing |
| `mlsStatus` | string | MLS status (e.g. Active, Sold) |
| `address` | string | Street line |
| `unit` | string | Unit / apartment number (if any) |
| `city` | string | City |
| `state` | string | US state code |
| `zip` | string | ZIP code |
| `price` | number | List price (or sold price) in USD |
| `hoa` | number | Monthly HOA dues, if reported |
| `beds` | number | Bedrooms |
| `baths` | number | Bathrooms |
| `sqft` | number | Interior square footage |
| `lotSize` | number | Lot size |
| `pricePerSqFt` | number | Price per square foot |
| `yearBuilt` | number | Year built |
| `propertyType` | string | e.g. Single Family Residential, Condo/Co-op, Townhouse |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `daysOnMarket` | number | Days on Redfin |
| `lastSoldDate` | string | ISO date of the property's most recent prior sale (null if none). On a `sold` listing this is that sale; on a for-sale listing it's the previous sale. |
| `url` | string | Canonical Redfin listing URL |
| `_schemaVersion` | string | Output schema version |
| `_scrapedAt` | string | ISO timestamp of the scrape |

**Two modes**, set with `listingType`:

- `forSale` — active for-sale listings (default).
- `sold` — recently sold homes (the sale date is in `lastSoldDate`, the sold price in `price`), for comps and sold-price analysis. Sold rows come from Redfin's public CSV comps feed, so `mlsStatus` is `Sold` and `listingId` is `null` (Redfin's internal listing id isn't exposed on that feed; `propertyId`, `mlsId` and `url` still are).

You can also choose the **sort order** (Redfin-recommended, price asc/desc, days-on-market asc/desc, or square-footage desc) and scrape **multiple regions in a single run**.

### Use cases

- **Real-estate investors & flippers** building a deal pipeline. Search intent: *"Redfin scraper", "scrape Redfin listings", "Redfin sold data export"*. Pull all for-sale homes in a metro, filter by `pricePerSqFt` and `daysOnMarket`, and surface underpriced inventory.
- **Proptech & CMA tools** needing a **Redfin API** alternative. Search intent: *"Redfin API", "Redfin data API no key"*. Feed `sold` listings with `lastSoldDate` and `price` into your comparative-market-analysis or AVM model.
- **Data & analytics teams** doing market research. Search intent: *"how to scrape Redfin", "Redfin real estate data to CSV/JSON"*. Track median price, inventory and days-on-market across cities over time via scheduled runs.
- **Lead-gen & local agents** monitoring a farm area. Search intent: *"Redfin listings scraper by ZIP"*. Watch a ZIP or neighborhood for new or price-dropped listings and trigger outreach.

### Input

| Field | Type | Notes |
|---|---|---|
| `redfinUrls` | string\[] | Redfin city / ZIP / county / neighborhood URLs. The region is read from the URL, and filters in a pasted search URL are applied (see FAQ). |
| `regions` | object\[] | Advanced alternative: `{ "region_id": "30818", "region_type": 6 }` (6=city, 2=zip, 5=county, 1=neighborhood). Note: `region_id` is Redfin's **internal** id, not a postal code — for a ZIP, paste the `/zipcode/…` URL instead (the actor resolves the internal id for you). |
| `listingType` | string | `forSale` (default) or `sold`. |
| `sort` | string | `redfin-recommended-asc`, `price-asc`, `price-desc`, `days-on-redfin-asc`, `days-on-redfin-desc`, `square-footage-desc`. Note: **Coming Soon** listings (`mlsStatus: "Coming Soon"`) often have no list price or a withheld address yet — Redfin orders them *first* under `price-desc`, so a handful of `price: null` rows at the top is Redfin's data, not a scrape gap. |
| `maxListings` | int | Cap total listings across all regions. Default `100`, max `17500`. |
| `numHomesPerPage` | int | Advanced — listings per request page. Default `350`. Leave at default. |

**For-sale by URL:**

```json
{
  "redfinUrls": ["https://www.redfin.com/city/30818/TX/Austin"],
  "listingType": "forSale",
  "sort": "price-desc",
  "maxListings": 500
}
```

**Sold comps for a city:**

```json
{
  "redfinUrls": ["https://www.redfin.com/city/30818/TX/Austin"],
  "listingType": "sold",
  "sort": "days-on-redfin-asc",
  "maxListings": 250
}
```

### Output sample

```json
{
  "_type": "listing",
  "_schemaVersion": "1.0",
  "listingId": 216197035,
  "propertyId": 31845362,
  "mlsId": "2116358131372161577",
  "mlsStatus": "Active",
  "address": "4602 Indian Wells Dr",
  "unit": null,
  "city": "Austin",
  "state": "TX",
  "zip": "78747",
  "price": 560000,
  "hoa": 45,
  "beds": 3,
  "baths": 2,
  "sqft": 2097,
  "lotSize": 7405,
  "pricePerSqFt": 267,
  "yearBuilt": 2019,
  "propertyType": "Single Family Residential",
  "latitude": 30.1327479,
  "longitude": -97.79,
  "daysOnMarket": 12,
  "lastSoldDate": null,
  "url": "https://www.redfin.com/TX/Austin/4602-Indian-Wells-Dr-78747/home/31845362",
  "_scrapedAt": "2026-06-01T08:08:20.543Z"
}
```

### Use with AI agents (MCP)

This scraper is callable as a tool by AI agents via the **[Apify MCP server](https://mcp.apify.com)** — so assistants like **Claude, Cursor, and VS Code** can run it and use the structured results mid-conversation, with no glue code.

Simplest path: in a recent **Claude Desktop**, add the hosted server `https://mcp.apify.com` under **Settings → Connectors** and authorize with OAuth. For any config-file client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask in plain language, e.g. *"Pull active Redfin listings for Austin, TX with price, beds, baths, and square footage."* — the agent calls **`freshactors/redfin-scraper`** with the right input and reads back the JSON. Full setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

**No Apify account?** x402-enabled AI agents can also run this actor autonomously and **pay per use via the x402 payment protocol** — no signup, subscription, or API token required.

### Pricing

**Volume discounts — applied automatically.** Running at scale on a paid Apify plan? The per-listing price drops with your plan tier — up to **35% off at Gold** and more on Platinum/Diamond, with no start fee and nothing to apply for. Free and Bronze keep the standard price shown below.

Pay-per-result, no subscription. You're charged **$0.0015 per listing returned** (the `listing-fetched` event) — that's it. You only pay for rows that actually land in your dataset.

**How much does 100 results cost?** 100 × $0.0015 = **$0.15**.

A few more reference points:

- 500 listings → **$0.75**
- 1,000 listings → **$1.50**
- 10,000 listings → **$15.00**

Set `maxListings` to keep any single run within your budget.

### FAQ

**Is scraping Redfin (US real estate) legal?**
This actor collects **publicly visible** listing data. Scraping public data is broadly permitted in many jurisdictions, but you're responsible for complying with Redfin's terms and applicable laws. Note that some MLS listings are excluded from Redfin's public data per local MLS rules — Redfin itself flags this — so those won't appear.

**Do I need an API key or a Redfin account?**
No. There's no Redfin account, login or API key. You paste a Redfin URL (or region IDs) and run the actor.

**Is there an official Redfin API?**
Redfin doesn't offer a public listings API. This actor is the practical substitute: structured JSON with the fields most people want, callable from the Apify API/SDK.

**How do I get sold listings instead of for-sale?**
Set `listingType` to `sold`. Sold rows carry the sale date in `lastSoldDate`, which is what you want for comps and sold-price trends.

**How do I scrape a specific city or ZIP?**
Paste the Redfin URL for it — e.g. `https://www.redfin.com/city/30818/TX/Austin` or `https://www.redfin.com/zipcode/78701`. The region is parsed from the URL automatically. A plain 5-digit ZIP (e.g. `78701`) is accepted too — **but since late October 2026 Redfin shows an automated-traffic check ("Human Verification") instead of the ZIP page this actor needs to look up a ZIP's area.** This actor does not try to get past such checks, so a ZIP input currently fails with exactly that message instead of a vague "retry". A city, neighborhood or county URL does not need that page and works normally — use one of those. If one entry is not a search area (e.g. a single home's page), it is skipped and named in the run status while the rest are delivered. For programmatic control, use the advanced `regions` input with `region_id` + `region_type`.

**How many listings can I get per run?**
Up to `maxListings`, which defaults to 100 and can go up to 17,500. You can also include multiple URLs/regions in one run; the cap applies across all of them.

**How often is the data updated?**
The actor reads **live** from Redfin every time you run it, so data is as fresh as Redfin's own site at run time. Schedule runs (hourly/daily) for ongoing monitoring.

**Why do some scrapers return zero results — does this one?**
Redfin's data endpoint returns a "Success" envelope even when it's quietly blocking bots, so naive scrapers return empty datasets. This actor detects that soft-block pattern and retries with backoff and IP rotation, so a real zero-result is distinguished from a block.

**Can I paste a filtered Redfin search?**
Yes. Set your filters on redfin.com and paste the resulting URL (e.g. `…/city/30818/TX/Austin/filter/property-type=house,min-price=300k,max-price=1.5M,min-beds=3`). Property type, min/max price, min/max beds, min baths and min/max square feet are applied, and you're only charged for listings that match. Any other filter in the URL is named in the run message as *not applied* — never dropped silently. The applied filters are recorded in the run's `RUN_SUMMARY`.

**What's the difference between `redfinUrls` and `regions`?**
`redfinUrls` is the easy path — paste any Redfin region page URL. `regions` is the advanced path for when you already know Redfin's internal `region_id` and `region_type` and want to script them directly.

**Can I export to CSV or Excel?**
Yes. Results go to a standard Apify dataset, which you can export as JSON, CSV, Excel, or HTML, or pull via the API.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details, reviews, search |
| [Microsoft Store Scraper](https://apify.com/freshactors/microsoft-store-scraper) | Microsoft Store — app details, rating windows, search, reviews |
| [VS Code Marketplace Scraper](https://apify.com/freshactors/vscode-marketplace-scraper) | VS Code extensions — install/trending stats, search, reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |
| [Workable Jobs Scraper](https://apify.com/freshactors/workable-jobs-scraper) | Workable — normalized job postings, full descriptions |
| [SmartRecruiters Jobs Scraper](https://apify.com/freshactors/smartrecruiters-jobs-scraper) | SmartRecruiters — normalized job postings, full descriptions |
| [Recruitee Jobs Scraper](https://apify.com/freshactors/recruitee-jobs-scraper) | Recruitee — normalized job postings + salary |
| [Teamtailor Jobs Scraper](https://apify.com/freshactors/teamtailor-jobs-scraper) | Teamtailor — normalized job postings, full descriptions |
| [Personio Jobs Scraper](https://apify.com/freshactors/personio-jobs-scraper) | Personio — normalized job postings, departments + seniority |

### Reliability

A scheduled **daily canary** runs this actor against live Redfin and checks that listings still parse and the expected fields are present. When Redfin changes its data API or block behavior, we patch quickly and record it in the changelog below, then bump the "Last verified working" date at the top. That feedback loop — *monitor, detect, patch, log* — is the whole point of FreshActors: an actor you can build a pipeline on without it quietly going stale.

**Changelog**

- **2026-10-28** — **City and neighborhood pages: a dropped connection is retried.** Loading a region page now retries a network error or a temporary server error with backoff (it used to be a single try). Redfin's "Human Verification" check is never retried — it is reported exactly as before.

- **2026-10-26** — **ZIP codes: Redfin now shows an automated-traffic check.** Redfin answers the ZIP page this actor needs (to look up a ZIP's area) with a "Human Verification" check. The old code read that check as the page and failed with "please retry"; a ZIP input now fails saying exactly what happened and points you to the input that works — a city, neighborhood or county URL. This actor does not try to get past bot checks. City, county and neighborhood URLs, sold comps and filtered searches are unaffected (verified 2026-10-26).

- **2026-10-15** — **One bad entry no longer fails the whole run.** An entry that is not a search area (e.g. a single home's page) is skipped and named in the run status while the other regions are delivered, and a plain 5-digit ZIP (e.g. `78701`) now works.

- **2026-10-12** — **Requests now rotate across proxy IPs as intended.** A misconfigured proxy setting had sent every request from a single IP; rotation makes large pulls far less likely to be rate-limited.

- **2026-10-12** — **Runs finish within your timeout, and say exactly what is missing.** A run now knows its own timeout and stops making requests shortly before it, so it ends with the data it already collected and a clear “Stopped early” note — instead of being killed as TIMED-OUT, which looked like a failure even though your data was there. If the source stops answering partway through a multi-page pull, that item is now listed as **INCOMPLETE** in the status message and `RUN_SUMMARY` (it used to end with a plain “Done”). And when a run fails because the source was rate-limiting or not responding, the message now says so first, instead of suggesting your input was wrong.

- **2026-10-08** — **No more hung runs.** Every request now has a 30-second deadline: if the source accepts a connection but never answers, that request is retried like any other network error instead of stalling the run until its timeout (and billing compute for the wait). No change to output fields or pricing.

- **2026-09-23** — **Filters in a pasted search URL are now applied.** A URL like `…/Austin/filter/property-type=house,min-price=300k,min-beds=3` previously returned the right area but silently ignored the filters. Property type, min/max price, min/max beds, min baths and min/max square feet are now honoured (and you are only charged for listings that match); any other filter in the URL is named in the run message as *not applied* rather than dropped quietly. Also: if Redfin could not be reached for every requested area, the run now fails and says so, instead of reporting success with zero listings; a partial pull keeps its data and names the missing area.

- **2026-09-17** — Freshness pass: re-verified every mode and documented option against live Redfin; documented that Coming-Soon listings carry no price / a withheld address and sort first under `price-desc`. No change to scraping behaviour, output schema, or pricing.

- **2026-08-03** — Volume discounts added: the per-listing price now scales down with your Apify plan tier — about **35% off at Gold** and **60% off at Diamond**, applied automatically with nothing to apply for. **Free and Bronze pay exactly what they did before — no price went up**, and there is still no start fee.

- **2026-08-03** — Freshness pass: re-verified across every mode, including that invalid input fails immediately with an actionable message naming the expected field rather than returning an empty result set.

- **2026-07-08** — Freshness pass: re-verified working across every mode via the daily monitoring battery; documented **x402** support (AI agents can run this actor pay-per-use with no Apify account). No change to scraping behavior, output, or pricing.

- **2026-06-06** — **Fixed `sold` mode**, which had been silently returning for-sale listings: Redfin's JSON endpoint ignores the sold filter, so sold mode now reads Redfin's CSV comps feed and returns genuinely sold homes (real sale date + sold price). **Fixed ZIP scraping**, which returned the wrong region: a `/zipcode/…` URL now resolves Redfin's internal region id instead of using the postal code (which pointed at an unrelated area). Both paths are now covered by the daily canary.

- **2026-06-04** — Renamed the `soldDate` output field to `lastSoldDate` and documented it honestly: Redfin returns the property's most recent *prior* sale on every listing (including for-sale homes), so the old `soldDate` label was misleading. Same data, accurate name. Also removed the opaque, undocumented `listingType` integer (no usable meaning, and it clashed with the `listingType` **input**).

- **2026-06-01** — v1.0 launch. For-sale + sold listings, URL-based region resolution, block-aware retry engine, daily canary monitoring.

**Legal note.** This actor scrapes **public** real-estate listing data. Some MLS listings are excluded per local MLS rules. Use the data responsibly and in line with Redfin's terms and applicable laws.

*Found a problem? Open an issue — answered fast. Staying fresh is the whole point.*

# Actor input Schema

## `redfinUrls` (type: `array`):

Paste Redfin search/city/zip URLs, e.g. https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. A plain 5-digit US ZIP (e.g. 78701) is accepted, but Redfin currently shows an automated-traffic check on the ZIP page this needs, so a ZIP may fail — a city, neighborhood or county URL works. The region is read from the URL. An entry that is not a search area (e.g. a single home's page) is skipped and named in the run status. Filters in a pasted search URL are applied (property type, min/max price, min/max beds, min baths, min/max sqft); any other filter is reported as not applied.

## `regions` (type: `array`):

Alternative to URLs: objects like { "region_id": "30818", "region_type": 6 } (6=city, 2=zip, 5=county, 1=neighborhood).

## `listingType` (type: `string`):

Scrape active for-sale listings or recently sold homes.

## `sort` (type: `string`):

Order in which listings are returned.

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

Cap total listings returned across all regions.

## `numHomesPerPage` (type: `integer`):

Listings fetched per request page (advanced; leave at default).

## Actor input object example

```json
{
  "redfinUrls": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "listingType": "forSale",
  "sort": "redfin-recommended-asc",
  "maxListings": 100,
  "numHomesPerPage": 350
}
```

# Actor output Schema

## `results` (type: `string`):

Real-estate listings with price, beds/baths, sqft, address, and more.

# 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 = {
    "redfinUrls": [
        "https://www.redfin.com/city/30818/TX/Austin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/redfin-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 = { "redfinUrls": ["https://www.redfin.com/city/30818/TX/Austin"] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/redfin-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 '{
  "redfinUrls": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ]
}' |
apify call freshactors/redfin-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,freshactors/redfin-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/APyGdXaoUR0sJEtrY/builds/ZGhtVfHxamIZN0rSV/openapi.json