# Zillow Scraper - Property Listings, Rentals, Sold & Agent Data (`automly/zillow-scraper`) Actor

Scrape Zillow homes for sale, rentals and recently sold listings by city, ZIP code, radius or Zillow search URL. 44 filters, Zestimates, price history, listing agent details, apartment floor plans and unit rents. Splits large searches past Zillow's 1,000-result limit. No login needed.

- **URL**: https://apify.com/automly/zillow-scraper.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Zillow Scraper — Export Zillow Listings, Rentals, Sold Homes & Agent Data

**Zillow Scraper** extracts **homes for sale, rentals, and recently sold listings** from Zillow as JSON, CSV, Excel, XML, or an API feed. Search by **city, ZIP code, neighborhood, radius around a map point, Zillow search URL, property URL, or ZPID**, then narrow results with **44 filters taken from Zillow's own search page**: price, beds, baths, home type, square feet, lot size, year built, HOA fee, days on Zillow, keywords, home features, and rental amenities. No Zillow account, cookies, or API key is needed.

This Actor is an independent tool, not affiliated with, endorsed by, or sponsored by Zillow. Its filters and output fields were last verified against live Zillow searches on 12 September 2026.

### What does Zillow Scraper do?

It turns any Zillow search into structured rows, one per property or apartment building. Every filter it offers was checked against live Zillow result counts, so a filter appears in the input only when Zillow provably applies it. Three things it does that most Zillow scrapers do not:

- **Returns more than one Zillow search can.** Zillow stops at 984 listings per search (24 pages of 41). When you ask for more, the Actor splits the search area into map quarters until each area fits, then merges and deduplicates. A 2,000-listing Austin run took 47 seconds in testing.
- **Expands apartment buildings.** With details enabled, each rental building returns its floor plans, available units, unit rents, square feet, leasing phone, amenities, pet policy, and Walk Score.
- **Finds the agent on Zillow Showcase listings,** which load the agent separately from the page, so a scraper that reads only the page markup misses it.

### Features

- Scrape Zillow homes for sale by city, ZIP code, or neighborhood
- Scrape Zillow rentals with rents, floor plans, and available units
- Scrape recently sold homes with sold price and sold date
- Search Zillow by latitude, longitude, and a radius in miles
- Get more than 1,000 results from one Zillow search area
- Filter by price, bedrooms, bathrooms, square feet, lot size, year built, HOA fee, and parking
- Filter for-sale listings by FSBO, new construction, coming soon, auctions, foreclosures, pending, and pre-foreclosures
- Filter by pool, garage, air conditioning, waterfront, single story, basement, views, 55+ communities, 3D tour, open house, and price cut
- Filter rentals by pets, move-in date, in-unit laundry, parking, furnished, utilities included, and 13 more amenities
- Get Zestimate, Rent Zestimate, price history, tax history, assigned schools with ratings, and Zillow's "What's special" highlights
- Get listing agent name, phone, broker, MLS number, and agent profile URL
- Return only listings earlier runs did not return, for scheduled monitoring
- Export to JSON, CSV, Excel, or XML, or pull results from the Apify API
- Use it as a Zillow API alternative with no daily call limit

### Use cases

- **Real estate lead generation:** lists of active listings with agent name, phone, and brokerage.
- **Comps and valuation:** recently sold homes with sold price, sold date, Zestimate, and price history by ZIP code or radius.
- **Rental market research:** asking rents, floor plans, and unit availability across apartment buildings.
- **Investor deal flow:** price cuts, FSBO, foreclosures, pre-foreclosures, and auctions in a target market.
- **Market dashboards:** days on market, inventory, and price trends feeding BI tools or a warehouse.
- **AI and machine learning:** labeled property records for price prediction and demand models.

### How to use the Zillow Scraper

1. Click **Try for free** to open the Actor in Apify Console.
2. Enter a location in **Locations to search**, such as `Austin, TX` or `78704`. You can paste Zillow URLs or ZPIDs instead, or set a latitude, longitude, and radius.
3. Pick a **Listing type**: for sale, for rent, or recently sold.
4. Set the filters you need, such as price range, bedrooms, home types, or rental amenities.
5. Set **Maximum results**, and turn on **Fetch full property details** for descriptions, agent contacts, floor plans, and photos.
6. Click **Start**, then download the data from the **Dataset** tab or fetch it from the API.

For scheduled runs, turn on **Skip listings from earlier runs** so each run returns only new listings.

### Input parameters

| Parameter | Type | Description |
|---|---|---|
| `searchTerms` | string\[] | Cities, ZIP codes, neighborhoods, or addresses, e.g. `["Austin, TX", "78704"]` |
| `startUrls` | array | Zillow search, property, or apartment-building URLs |
| `zpids` | string\[] | Zillow property IDs |
| `latitude`, `longitude`, `radiusMiles` | number | Radius search around a map point |
| `listingType` | string | `sale`, `rent`, or `sold` |
| `maxResults` | integer | Cap on unique rows across all inputs |
| `sortBy` | string | `relevance`, `priceLowToHigh`, `priceHighToLow`, `newest`, `bedrooms`, `bathrooms`, `squareFeet`, `lotSize` |
| `minPrice`, `maxPrice` | integer | List or sold price; monthly rent for rentals |
| `minBeds`, `maxBeds`, `minBaths` | number | Bedroom and bathroom limits |
| `homeTypes` | string\[] | `houses`, `townhomes`, `multiFamily`, `condos`, `apartments`, `lotsLand`, `manufactured` |
| `minSqft`, `maxSqft`, `minLotSize`, `maxLotSize` | integer | Living area and lot size in square feet |
| `minYearBuilt`, `maxYearBuilt`, `maxHoa`, `minParkingSpots` | integer | Year built range, HOA cap, parking minimum |
| `daysOnZillow` | string | `1`, `7`, `14`, `30`, `90`, `6m`, `12m`, `24m`, `36m` |
| `keywords` | string | Words Zillow matches in the listing |
| `includeDetails` | boolean | Visit each property or building page for full details |
| `skipSeenListings` | boolean | Skip listings returned by earlier runs |
| `saveBatchSize` | integer | Rows written to the dataset per request (default 1, each row saved as it is scraped) |
| `proxyConfiguration` | object | Apify proxy settings; US residential is recommended |

For-sale category switches, home-feature filters, and 18 rental amenities round out the **Input** tab's 59 fields.

### Output example

A real row from a radius search in Austin, trimmed to the common fields:

```json
{
  "zpid": "119632104",
  "url": "https://www.zillow.com/homedetails/1303-Azie-Morton-Rd-12-Austin-TX-78704/119632104_zpid/",
  "address": "1303 Azie Morton Rd #12, Austin, TX, 78704",
  "price": 1195000,
  "currency": "USD",
  "zestimate": 1140000,
  "rentZestimate": 7504,
  "bedrooms": 4,
  "bathrooms": 3,
  "livingArea": 2068,
  "lotAreaValue": 4922.28,
  "homeType": "SINGLE_FAMILY",
  "homeStatus": "FOR_SALE",
  "yearBuilt": 2011,
  "daysOnZillow": 0,
  "brokerName": "Keller Williams Realty",
  "agentName": "Anthony Gibson",
  "agentPhoneNumber": "512-699-8507",
  "mlsId": "5038445",
  "latitude": 30.25869,
  "longitude": -97.7725,
  "sourceQuery": "30.2672,-97.7431 within 2.0 mi",
  "searchRank": 4
}
```

Rows also carry `description`, `whatsSpecial`, `photos`, `priceHistory`, `taxHistory` (each entry with its assessment `year`), `schools`, `assignedSchools`, `resoFacts`, `monthlyHoaFee`, `propertyTaxRate`, `lastSoldPrice`, `dateSold`, `priceChange`, `agentEmail`, `agentProfileUrl`, `mlsName`, and a UTC `scrapedAt` timestamp, when Zillow publishes them. Schools, tax history and the highlights are not part of Zillow's property page, so the Actor fetches them with one extra request per property.

An apartment building row from a rental search:

```json
{
  "zpid": "30.376558--97.62932",
  "url": "https://www.zillow.com/apartments/austin-tx/the-janis/CqW86G/",
  "buildingName": "The Janis",
  "address": "3500 E Parmer Ln, Austin, TX 78754",
  "price": 1523,
  "minBaseRent": 1449,
  "maxBaseRent": 1845,
  "availabilityCount": 57,
  "unitCount": 422,
  "buildingPhoneNumber": "(737) 352-4109",
  "walkScore": 5,
  "floorPlans": [
    {
      "name": "1A",
      "beds": 1,
      "baths": 1,
      "sqft": 731,
      "minPrice": 1523,
      "maxPrice": 1553,
      "units": [
        {"unitNumber": "Unit 1103", "zpid": "449016845", "price": 1538, "baseRent": 1464, "sqft": 731}
      ]
    }
  ]
}
```

### How much does it cost?

The Actor has no subscription fee, so you pay only Apify platform usage. Two measured runs on Apify with US residential proxies at 4 GB memory:

| Run | Rows | Time | Platform usage |
|---|---|---|---|
| Austin rentals with apartment building details | 20 | 18 s | $0.023 |
| Austin sale radius with full property details | 15 | 47 s | $0.022 |

Both runs cost about $0.02 in total platform usage. Runs without `includeDetails` need far fewer requests per row: one Zillow search request returns 41 listings.

### Limits and responsible use

- Above roughly 1,000 listings, the Actor splits the search area into quarters until each area has fewer than 900 results, so rows follow your sort order within each map area rather than across the whole search, and `searchPage` restarts at 1 in each area.
- `minBaseRent`, `maxBaseRent`, `availabilityCount` and `floorPlans` describe apartment buildings. Single-home rentals carry one `price` instead, and for-sale and sold rows leave them empty. The Output tab's views select columns and cannot filter rows, so the rental view also lists sale rows — filter on `homeStatus` when exporting.
- Fields vary by listing status and state. Missing values come back as `null` or an empty array; the Actor does not invent data. Sold prices are empty in non-disclosure states such as Texas.
- `includeDetails` adds two requests per property (the page, then the schools, tax-history and highlights call) or one per apartment building, plus one for the agent on Showcase listings. Rows are saved as their detail pages finish, so dataset order can differ from search order — sort by `searchRank` to restore it.
- Only filters Zillow actually applies are offered. School rating, accepting-backup-offers, and photos-only filters are excluded because Zillow's search ignored them in testing.
- Scrape public information responsibly and make sure your use complies with applicable laws, contracts, privacy rules, and Zillow's terms.

### FAQ

#### Do I need a Zillow API key or account?

No. The Actor reads public Zillow search and listing pages, so there is no login, cookie, or API key, and no daily call limit.

#### Can I get more than 1,000 listings from one Zillow search?

Yes. Zillow itself stops at 984 listings per search (24 pages of 41). When `maxResults` is higher, the Actor splits the search map into quarters until each area fits, then deduplicates by property. In testing it returned 2,000 unique Austin listings in 47 seconds.

#### Can I search Zillow by coordinates and radius?

Yes. Set `latitude`, `longitude`, and `radiusMiles`. The Actor searches the map box around that circle and drops rows outside the radius, so every row is within the distance you asked for.

#### Does it return apartment floor plans and unit rents?

Yes. With `includeDetails`, each rental building returns floor plans, available units, unit-level rents and square feet, leasing phone, amenities, pet policy, specials, and Walk, Transit, and Bike Scores. Both `/apartments/` and older `/b/` building URLs work.

#### Can I get the listing agent's name and phone number?

Yes, when Zillow publishes them: `agentName`, `agentPhoneNumber`, `agentEmail`, `brokerName`, `mlsId`, and `agentProfileUrl`. On Zillow Showcase listings the agent is fetched separately, so that field is filled too.

#### Why are some sold prices empty?

Texas and other non-disclosure states do not publish sale prices, so Zillow shows none. Sold date, address, and property details are still returned.

#### Can I scrape only new Zillow listings each day?

Yes. Turn on `skipSeenListings`, give it a store name, and schedule the run. Each run returns only listings earlier runs with that store name did not return. Pair it with `sortBy: "newest"`.

#### Why are there no school-rating filters?

Zillow's search ignores them. In testing, six variants of its school filter keys — including Zillow's own `enableSchools` switch — left an Austin search at 5,665 results, meaning the filter was never applied. Assigned schools and their ratings are still returned per property.

#### Is it legal to scrape Zillow?

The Ninth Circuit held that accessing publicly available web data does not violate the Computer Fraud and Abuse Act (hiQ Labs v. LinkedIn, 2022). This Actor only reads public pages and never logs in. That is not legal advice: review Zillow's terms and the rules that apply to your use, especially for personal data.

#### Which proxies should I use?

US residential is the default and the safer choice for property and building detail pages, where Zillow's checks are strictest. In testing, Apify's datacenter proxy also returned a full 500-listing search with no blocks, at about the same platform cost, so listings-only runs can use either. Temporary blocks are retried with exponential backoff.

#### What export formats are supported?

JSON, CSV, Excel, XML, HTML, and RSS from the Dataset tab, plus the Apify API, webhooks, and integrations such as Google Sheets, Slack, Zapier, and Make.

# Actor input Schema

## `searchTerms` (type: `array`):

Cities, ZIP codes, neighborhoods, or addresses, for example Austin, TX or 78704.

## `startUrls` (type: `array`):

Zillow search-result or property-detail URLs. Filters set below are added on top of a search URL's own filters.

## `zpids` (type: `array`):

Specific Zillow property IDs to retrieve. Search filters do not apply to ZPIDs.

## `latitude` (type: `number`):

Center of a radius search, for example 30.2672. Set latitude, longitude and radius together.

## `longitude` (type: `number`):

Center of a radius search, for example -97.7431.

## `radiusMiles` (type: `number`):

Only return listings within this many miles of the latitude and longitude.

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

Used for Locations to search and the radius search.

## `maxResults` (type: `integer`):

Maximum number of unique dataset rows across all inputs.

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

Order of search results. Price sorts use monthly rent for rentals.

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

Minimum list or sold price. For rentals this is the minimum monthly rent.

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

Maximum list or sold price. For rentals this is the maximum monthly rent.

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

Minimum number of bedrooms.

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

Maximum number of bedrooms.

## `minBaths` (type: `number`):

Minimum number of bathrooms, for example 1.5 or 2.

## `homeTypes` (type: `array`):

Only return these home types. Leave empty for all. Rentals treat apartments and condos as one type and ignore multi-family, lots/land, and manufactured.

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

Minimum living area in square feet.

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

Maximum living area in square feet.

## `minLotSize` (type: `integer`):

Minimum lot size in square feet. 1 acre = 43,560 sq ft.

## `maxLotSize` (type: `integer`):

Maximum lot size in square feet. 1 acre = 43,560 sq ft.

## `minYearBuilt` (type: `integer`):

Earliest year built.

## `maxYearBuilt` (type: `integer`):

Latest year built.

## `maxHoa` (type: `integer`):

Maximum monthly HOA fee.

## `includeHomesWithNoHoaData` (type: `boolean`):

Keep homes that have no HOA information when Maximum HOA fee is set.

## `minParkingSpots` (type: `integer`):

Minimum number of parking spots (for-sale and sold searches).

## `daysOnZillow` (type: `string`):

Only listings posted within this window. For recently sold searches, only homes sold within this window.

## `keywords` (type: `string`):

Words Zillow should match in the listing, for example: pool, casita.

## `includeAgentListed` (type: `boolean`):

Include homes listed by an agent.

## `includeOwnerListed` (type: `boolean`):

Include homes for sale by owner.

## `includeNewConstruction` (type: `boolean`):

Include new construction homes.

## `includeComingSoon` (type: `boolean`):

Include coming-soon listings.

## `includeAuctions` (type: `boolean`):

Include auction listings.

## `includeForeclosures` (type: `boolean`):

Include bank-owned homes listed for sale.

## `includePending` (type: `boolean`):

Also include pending and under-contract listings.

## `includePreForeclosures` (type: `boolean`):

Also include off-market pre-foreclosure homes.

## `includeForeclosed` (type: `boolean`):

Also include bank-owned homes that are not listed for sale yet.

## `mustHavePool` (type: `boolean`):

Only homes with a pool.

## `mustHaveGarage` (type: `boolean`):

Only homes with a garage.

## `mustHaveAirConditioning` (type: `boolean`):

Only homes with air conditioning.

## `waterfrontOnly` (type: `boolean`):

Only waterfront homes.

## `singleStoryOnly` (type: `boolean`):

Only single-story homes.

## `basement` (type: `string`):

Only homes with this kind of basement.

## `views` (type: `array`):

Only homes with at least one of these views. Leave empty for any.

## `seniorCommunities` (type: `string`):

Only show, or hide, homes in 55+ communities.

## `has3dTour` (type: `boolean`):

Only listings with a 3D home tour.

## `showcaseOnly` (type: `boolean`):

Only Zillow Showcase listings.

## `openHousesOnly` (type: `boolean`):

Only listings with an upcoming open house.

## `priceReducedOnly` (type: `boolean`):

Only listings with a recent price cut.

## `roomsForRentOnly` (type: `boolean`):

Only individual rooms instead of entire places.

## `moveInDate` (type: `string`):

Only rentals available on or before this date (YYYY-MM-DD).

## `pets` (type: `array`):

Only rentals that allow these pets.

## `noPets` (type: `boolean`):

Only rentals that do not allow pets.

## `rentalAmenities` (type: `array`):

Only rentals that have all of these amenities.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for Zillow pagination per search URL.

## `includeDetails` (type: `boolean`):

Visit each property or apartment-building page to enrich search rows with description, facts, agent, MLS, floor plans, photos, and other details. Uses more requests.

## `skipSeenListings` (type: `boolean`):

Only return listings that earlier runs using the same store name did not return. Useful for scheduled runs that should only deliver new listings.

## `seenListingsStoreName` (type: `string`):

Name of the key-value store that remembers returned listings. Use a different name for each separate search you monitor.

## `includeRawData` (type: `boolean`):

Include Zillow's source search/property objects. This can make dataset rows very large.

## `maxConcurrency` (type: `integer`):

Maximum simultaneous property-detail requests.

## `saveBatchSize` (type: `integer`):

How many rows to write to the dataset per request. Apify bills dataset writes per row, so batching does not reduce that cost, it only cuts API round-trips. At the default of 1 every row is saved the moment it is scraped; higher values lose up to that many rows if a run is killed, and rows never wait longer than 5 seconds.

## `proxyConfiguration` (type: `object`):

US residential proxies are the default and the safer choice for property and building detail pages. Apify's datacenter proxy also returned a full 500-listing search with no blocks in testing.

## Actor input object example

```json
{
  "searchTerms": [
    "Austin, TX"
  ],
  "listingType": "sale",
  "maxResults": 100,
  "sortBy": "relevance",
  "includeHomesWithNoHoaData": true,
  "includeAgentListed": true,
  "includeOwnerListed": true,
  "includeNewConstruction": true,
  "includeComingSoon": true,
  "includeAuctions": true,
  "includeForeclosures": true,
  "includePending": false,
  "includePreForeclosures": false,
  "includeForeclosed": false,
  "mustHavePool": false,
  "mustHaveGarage": false,
  "mustHaveAirConditioning": false,
  "waterfrontOnly": false,
  "singleStoryOnly": false,
  "has3dTour": false,
  "showcaseOnly": false,
  "openHousesOnly": false,
  "priceReducedOnly": false,
  "roomsForRentOnly": false,
  "noPets": false,
  "maxPagesPerSearch": 25,
  "includeDetails": false,
  "skipSeenListings": false,
  "seenListingsStoreName": "zillow-seen-listings",
  "includeRawData": false,
  "maxConcurrency": 5,
  "saveBatchSize": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

No description

## `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 = {
    "searchTerms": [
        "Austin, TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/zillow-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 = { "searchTerms": ["Austin, TX"] }

# Run the Actor and wait for it to finish
run = client.actor("automly/zillow-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 '{
  "searchTerms": [
    "Austin, TX"
  ]
}' |
apify call automly/zillow-scraper --silent --output-dataset

```

## MCP server setup

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