# Yad2 Scraper (`dami_studio/yad2-scraper`) Actor

Yad2 scraper for Israel's classifieds: cars and other vehicles, property for sale or rent, and second-hand goods. Filter or paste a search URL and get one row per listing: Hebrew title, price in shekels, city, seller type, specs, photos, publish date. $1.20 per 1,000 listings.

- **URL**: https://apify.com/dami_studio/yad2-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Real estate, E-commerce, Lead generation
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 35 total users, 15 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.14 / 1,000 listings

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

**Yad2 scraper for Israeli cars, property and second-hand listings, one row per listing**: the Hebrew title, the price in shekels, city and area, private seller or dealer, photos, the publish date and the link.

One thing shapes every search. There is no keyword box for vehicles and property: you filter by manufacturer, area, region, price and year instead. The second-hand marketplace is the opposite. It needs a search term.

| | |
|---|---|
| **Input** | A section plus filters, or Yad2 search URLs |
| **Output** | One row per listing: Hebrew title, price in shekels, city and area, seller type, vehicle or property details, photos, publish date, link |
| **Ceiling** | 50,000 listings per run |
| **Account needed** | None |
| **Price** | $1.20 per 1,000 listings on the Free plan, a little less on paid plans. The free plan's $5 a month covers about 4,000 |

### 🔍 What Yad2 Scraper does

Three parts of Yad2 in one actor. Vehicles covers cars, motorcycles, scooters, trucks and watercraft. Real estate covers apartments and houses for sale, for rent, and commercial property. Second-hand goods is Yad2's marketplace.

Names work in Hebrew or English on both sides. `טויוטה` and `Toyota` resolve to the same manufacturer, and so do `אזור חיפה והסביבה` and `Haifa area`. 69 manufacturers and 43 areas are recognised, and an unknown name is reported rather than silently ignored.

Real estate is read region by region, and each region is split into price bands.

### 📋 What data you get from each Yad2 listing

| What you get | Field |
|---|---|
| Yad2's listing id, ad number and link | `listingId`, `adNumber`, `url` |
| Section and sub-section, with Yad2's category ids | `section`, `subSection`, `categoryId`, `subCategoryId` |
| A title built from the listing's fields, Yad2's own headline and the description | `title`, `yad2Title`, `description` |
| Price in shekels and the previous price | `price`, `currency`, `previousPrice` |
| Private or business seller, its name and id, and the contact name | `sellerType`, `sellerName`, `sellerId`, `contactName` |
| City, area, region, neighbourhood, street and coordinates | `city`, `area`, `areaId`, `region`, `neighborhood`, `street`, `latitude`, `longitude` |
| When it was published and last updated | `publishedAt`, `updatedAt` |
| Vehicles: make, model, trim, year, hand, engine and kilometres | `manufacturer`, `model`, `subModel`, `year`, `hand`, `engineType`, `engineVolume`, `kilometers` |
| Property: rooms, size, floor and type | `rooms`, `squareMeters`, `floor`, `propertyType` |
| Second-hand goods: condition and tags | `condition`, `tags` |
| Photos and how many | `images`, `imageCount` |
| The pasted URL that found it, and when it was read | `searchUrl`, `scrapedAt` |

### ▶️ How to scrape Yad2 listings

1. Open [Yad2 Scraper](https://apify.com/dami_studio/yad2-scraper) and click **Try for free**.
2. Pick a **Section**. For second-hand goods, type a Hebrew **Search term**.
3. Add filters: manufacturer and area for vehicles, region or city id for property, price for both.
4. Set **Maximum listings**. Start around 100 to see the output shape, then click **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it from the Apify API.

Run it with no section and no URL and you get one labelled sample row on its own, not charged.

### 💰 How much does it cost to scrape Yad2?

**$1.20 per 1,000 listings** on the Free plan. Paid plans pay a little less: $1.18 on Starter, $1.16 on Scale and $1.14 on Business. On the free plan, the $5 Apify gives you each month covers about 4,000 listings.

You pay per listing row delivered. The sample row, diagnostic rows, duplicates and listings dropped by the seller-type filter carry no listing charge, and a search that matches nothing produces none either. The detail pass costs nothing extra per listing.

### 📥 What you give it

```json
{
  "section": "vehicles",
  "vehicleType": "cars",
  "manufacturers": ["Toyota"],
  "areas": ["Tel Aviv-Yafo area"],
  "minYear": 2018,
  "maxPrice": 120000,
  "maxItems": 500
}
```

| Field | Default | What it is |
|---|---|---|
| `section` | none, the form starts at `vehicles` | `vehicles`, `realestate` or `products`. With no section and no URL you get the sample row. |
| `vehicleType` | `cars` | `cars`, `motorcycles`, `scooters`, `trucks`, `watercraft`. Vehicles only. |
| `dealType` | none, the form starts at `forsale` | `forsale`, `rent` or `commercial`. Real estate only. |
| `query` | none, the form starts at `ספה` | The search term for second-hand goods, which need one. Hebrew works best. Ignored on vehicles and real estate. |
| `searchUrls` | none | Paste Yad2 search URLs instead of filling the fields. Section, manufacturer, model, area, region, city, price, year, km and hand are all read out of the URL. |
| `manufacturers` | none | Vehicles only. Hebrew or English names, or Yad2 ids. Each one is crawled as its own search. |
| `areas` | none | Vehicles only. Hebrew or English area names, or ids. |
| `regions` | none | Real estate only. Yad2 has exactly 8. Leave it empty to sweep all of them. |
| `cityId` | none | Real estate only. Yad2's numeric city code, from the `city=` parameter of a Yad2 URL. |
| `minRooms` | none | Real estate only, pasted real-estate URLs included. The fewest rooms, counted the way Yad2 counts them, so `3.5` works. Yad2 applies it. On a vehicle or second-hand search it stops that search with a free `BAD_INPUT` row. |
| `minPrice`, `maxPrice` | none | In new shekels. |
| `minYear`, `maxYear` | none | Vehicles only. |
| `maxKm` | none | Vehicles only. Upper bound on the odometer. |
| `sellerType` | any | `private` or `business`. See the note below. |
| `includeDetails` | on | One extra request per listing for the publish date, the written Hebrew title and the description. Turn it off to run faster. |
| `businessOnly` | off | Second-hand goods only. Shops rather than individuals. |
| `maxItems` | `100` | Total listings to return, 1 to 50,000. |
| `proxyConfiguration` | none | Optional. Only touch it if the run has to leave through your own servers. |

**`sellerType` is applied after the results come back.** Listings that do not match are dropped and never charged. On vehicles the crawl also stops once a full round of results contains none of your seller type, so a narrow filter can return fewer than `maxItems` while more matches exist further down.

**Rows are written at the end of the run, after the detail pass.** Near its time limit, a run stops looking in time to write what it has, plus a free `TIME_LIMIT` row. For very large pulls with details on, split them across runs or turn `includeDetails` off.

**A `cityId` with no `regions` sweeps all eight to find the right one.** You will see a handful of `NO_RESULTS` rows next to your real results. They are not charged.

### 📤 What you get back

A real car listing, with most of the photo URLs cut:

```json
{
  "listingId": "bdevnzns",
  "section": "vehicles",
  "subSection": "cars",
  "title": "טויוטה RAV4 Limited היברידי אוט׳ 2.5 (155 כ״ס) 2017",
  "yad2Title": "טויוטה RAV4 שנת 2017 יד שלישית 204,000 ק\"מ",
  "contactName": "גל",
  "description": "טויוטה ראב4 ההיברידית, רכב אמין במיוחד עם חיסכון בדלק...",
  "price": 82900,
  "currency": "ILS",
  "previousPrice": null,
  "sellerType": "business",
  "sellerName": "אוטו אדיר",
  "sellerId": "5263113",
  "categoryId": 1,
  "subCategoryId": 21,
  "city": "פתח תקווה",
  "area": "פתח תקווה והסביבה",
  "areaId": 4,
  "region": null,
  "neighborhood": null,
  "street": null,
  "latitude": null,
  "longitude": null,
  "publishedAt": "2026-07-02T12:48:55+03:00",
  "updatedAt": "2026-09-14T08:45:58+03:00",
  "manufacturer": "טויוטה",
  "model": "RAV4",
  "subModel": "Limited היברידי אוט׳ 2.5 (155 כ״ס)",
  "year": 2017,
  "hand": "יד שלישית",
  "engineType": "היברידי בנזין",
  "engineVolume": 2494,
  "kilometers": 204000,
  "rooms": null,
  "squareMeters": null,
  "floor": null,
  "propertyType": null,
  "condition": null,
  "tags": ["גלגלי מגנזיום", "בקרת שמירת מרחק", "בקרת שיוט אדפטיבית"],
  "images": ["https://images.yad2.co.il/Pic/202607/02/1_3/o/y2_1pa_010458_...", "..."],
  "imageCount": 8,
  "adNumber": "57171185",
  "url": "https://www.yad2.co.il/vehicles/item/bdevnzns",
  "searchUrl": null,
  "scrapedAt": "2026-09-14T05:48:04.651Z"
}
```

Every section returns the same columns, and the ones that do not apply are `null`. A flat has no odometer reading and a car has no room count, and both fit one table.

| Field | How to read it |
|---|---|
| `listingId` | Stable. Use it as your dedupe key. |
| `title` | Built from the structured fields. `yad2Title` is the wording Yad2 shows on the item page, and comes from the detail request. |
| `price`, `previousPrice` | Shekels. `price` is `null` rather than `0` when the seller did not publish one. |
| `sellerType` | `private` or `business` where Yad2 says so, otherwise its own raw wording. |
| `publishedAt`, `updatedAt` | Israel time, with the offset. Only present after a successful detail request, and never on second-hand goods. |
| `hand` | How many owners the vehicle has had, in Yad2's own Hebrew wording. |
| `propertyType` | The property type on real estate, and the product type on second-hand goods. |
| `url` | The item page. Second-hand goods point at `market.yad2.co.il` instead. |

### 🧾 Reading the output

Three kinds of row can land in your dataset.

| Row | How to spot it | Charged |
|---|---|---|
| A listing | It has a `listingId` and neither flag below | yes |
| The sample row | `_sample: true` | no |
| A diagnostic | `_diagnostic: true` and an `errorCode` | no |

A real listing row carries no `charged` field, so filter on `_sample` and `_diagnostic` being absent.

| Code | What it means |
|---|---|
| `BAD_INPUT` | A manufacturer, area, region or URL you gave was not recognised, or `minRooms` was set outside real estate. The row names which one. When none of the names in a list are recognised, that search is not run at all, so it never falls back to everything. The rest of the run carries on. |
| `NO_RESULTS` | That search ran and matched nothing. Widen the price range or drop a filter. |
| `NOT_SERVED` | This listing was not served this run. Re-run it later. Runs before 13 October 2026 wrote `BLOCKED` here. |
| `TIME_LIMIT` | The run got close to its time limit and stopped on its own. The listings delivered before that are in the dataset and charged as usual. Give the run more time, or ask for fewer listings, to get the rest. |
| `COST_LIMIT` | The run reached the maximum cost you set and stopped. The listings delivered before that are in the dataset and charged as usual. Raise the maximum cost to get the rest. |
| `UNEXPECTED_ERROR` | The run stopped early on an unexpected error. The results before this row are kept. |

A run still ends as succeeded, with an amber status message, even when the time limit stopped it before any listing came back.

**If a detail request fails for one listing, the row is still returned and still charged**, with `publishedAt`, `description` and `yad2Title` left `null` and nothing on the row to mark it. Check for a `null` publish date on vehicle and property rows if that field matters to you.

### 💡 What people use it for

- Watching one manufacturer and area daily and picking up what was listed since yesterday, deduping on `listingId`.
- Building a price curve for a model by year and mileage across a few thousand rows.
- Pulling a rental region with `sellerType` on private to skip the agencies.
- Tracking how long listings stay up, by comparing `publishedAt` against when they stop appearing.

### 🚧 What it does not do

- **No contact details.** `contactName` and `sellerName` are as far as it goes.
- **No keyword search on vehicles or property.** Use the filters.
- **Second-hand goods need a search term** and come back without a publish date.
- **Real estate is deep, not complete.** A region reaches a few thousand listings, not everything Yad2 holds.
- **Roommates and agricultural machinery are not covered.**
- **Second-hand results are not repeatable.** Two identical runs return overlapping rather than identical sets.
- **A pasted URL wins.** The form's year, kilometre, manufacturer and area fields are ignored for that search.
- **Rows are a snapshot.** A listing can be edited, sold or removed afterwards, and `scrapedAt` records when it was read.
- It is not an official Yad2 tool. Dami's Studio is independent and is not affiliated with or endorsed by Yad2, or by any other company named on this page.

### 🧭 Which classifieds scraper do you need?

| If you want | Use |
|---|---|
| Israeli classifieds: cars, property and second-hand goods | This one |
| Brazilian classified ads on OLX | [OLX Brazil Scraper](https://apify.com/dami_studio/olx-brazil-scraper) |
| Russian classified ads on Avito | [Avito Listings Scraper](https://apify.com/dami_studio/avito-listings-scraper) |
| UK classified ads by keyword, town or postcode | [Gumtree UK Scraper](https://apify.com/dami_studio/gumtree-uk-scraper) |
| Used and new cars across eight European countries | [AutoScout24 Scraper](https://apify.com/dami_studio/autoscout24-scraper) |

### ❓ Questions people ask

#### Do I need Hebrew?

Not for the filters. Manufacturer and area names work in English. The second-hand search term does better in Hebrew.

#### Where do I find a city id?

Open the city on Yad2 and read the `city=` value out of the URL. 5000 is Tel Aviv-Yafo, 3000 Jerusalem, 4000 Haifa.

#### Why is `publishedAt` empty?

Either the listing is second-hand goods, which carry no date, or you turned the detail pass off, or that one detail request did not come back.

#### How many listings can I get?

Up to 50,000 in one run.

#### Do I need a Yad2 account?

No. Everything it reads is public, and there is nothing to sign in to.

#### Can I call it from code or connect it to an AI assistant?

The [API tab](https://apify.com/dami_studio/yad2-scraper/api/python) has code for Python, JavaScript and the CLI. MCP
clients like Claude and ChatGPT use `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/yad2-scraper`;
coding assistants can load [our skill
file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-classifieds-property-SKILL.md). All
three bill your Apify account at the same price.

#### Is scraping Yad2 legal?

These are public listings on public pages. They carry personal data all the same, such as a seller's first name, which GDPR and similar laws cover, so have a reason for collecting it. Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the section and filters you used, or the URL, and the run ID. The `errorCode` on the diagnostic row usually names the problem on its own.

# Actor input Schema

## `section` (type: `string`):

Which part of Yad2 to scrape. Vehicles = cars, motorcycles, scooters, trucks, watercraft. Real estate = apartments and houses for sale, for rent, and commercial property. Second-hand goods = Yad2's marketplace, which needs a search term.

## `vehicleType` (type: `string`):

Only used when Section is Vehicles.

## `dealType` (type: `string`):

Only used when Section is Real estate.

## `query` (type: `string`):

Required for the second-hand marketplace, which has no browse-everything view. Hebrew works best: ספה (sofa), אופניים (bicycle), מקרר (fridge). Latin brand names such as iPhone or PlayStation also work. Yad2's vehicle and real-estate feeds have no free-text search at all, so this field is ignored for those sections - filter with manufacturer, area, region and price instead.

## `searchUrls` (type: `array`):

Optional. Paste Yad2 search URLs instead of filling in the fields, e.g. https://www.yad2.co.il/vehicles/cars?manufacturer=19\&year=2018-2024 or https://www.yad2.co.il/realestate/forsale?city=5000. The section, manufacturer, model, area, region, city, price, year, km and hand filters in the URL are all read.

## `manufacturers` (type: `array`):

Optional, vehicles only. Hebrew or English names both work: "Toyota", "טויוטה", "Mercedes-Benz", "Hyundai", "Tesla". 69 manufacturers are recognised. Each one is crawled as its own search.

## `areas` (type: `array`):

Optional, vehicles only. Yad2 area by Hebrew or English name ("Tel Aviv-Yafo area", "אזור חיפה והסביבה", "Beer Sheva area") or numeric id. 43 areas are recognised.

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

Optional, real estate only. Yad2 splits the country into exactly 8 regions: Center and Sharon (1), South (2), Tel Aviv and surroundings (3), Judea and Samaria (4), Northern coastal plain (5), Jerusalem (6), North and the valleys (7), Jerusalem area (8). Hebrew names and ids both work. Leave empty to sweep all eight.

## `cityId` (type: `integer`):

Optional, real estate only. Yad2's numeric city code, e.g. 5000 = Tel Aviv-Yafo, 3000 = Jerusalem, 4000 = Haifa. Take it from the city= parameter of a Yad2 URL. A city only matches inside its own region, so leave Regions empty and the actor will find the right one.

## `minRooms` (type: `number`):

Optional, real estate only. The fewest rooms a listing may have, counted the way Yad2 counts them, so 3.5 works. Yad2 applies it, so you only get and pay for listings that match. Set on a vehicle or second-hand search, that search is not run.

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

Optional. Prices are in Israeli new shekels.

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

Optional. Prices are in Israeli new shekels.

## `minYear` (type: `integer`):

Earliest model year to keep. Vehicle categories only, it is ignored on property and other listings.

## `maxYear` (type: `integer`):

Latest model year to keep. Vehicle categories only, it is ignored on property and other listings.

## `maxKm` (type: `integer`):

Optional, vehicles only. Upper bound on the odometer reading.

## `sellerType` (type: `string`):

Yad2 has no seller filter, so this is applied by the actor after the results come back. Listings that do not match are dropped and are never charged.

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

On by default for vehicles and real estate. Yad2's list feeds carry no publish date, no description and no written title, so the actor makes one extra request per listing to get them. Turn this off to run roughly twice as fast when you only need price, location and photos. Second-hand goods already include their title in the list feed and are unaffected.

## `businessOnly` (type: `boolean`):

Optional, second-hand goods only. Return only listings from Yad2 business sellers.

## `maxItems` (type: `integer`):

How many listings to return in total. Each returned listing is one charged result; dropped, duplicate and failed rows are never charged. A single vehicle search reaches about 59,000 listings; a real-estate region reaches a few thousand through automatic price-band splitting.

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

Optional. Leave it empty for a normal run. Add your own proxy servers here only if you want requests to go through them.

## Actor input object example

```json
{
  "section": "vehicles",
  "vehicleType": "cars",
  "dealType": "forsale",
  "query": "ספה",
  "searchUrls": [],
  "manufacturers": [],
  "areas": [],
  "regions": [],
  "sellerType": "any",
  "includeDetails": true,
  "businessOnly": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per listing in the default dataset: id, Hebrew title, price in ILS, city and area, private vs dealer, publish date, photos and the listing URL. Empty or blocked runs return a single uncharged row instead.

# 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 = {
    "section": "vehicles",
    "vehicleType": "cars",
    "dealType": "forsale",
    "query": "ספה",
    "searchUrls": [],
    "manufacturers": [],
    "areas": [],
    "regions": [],
    "sellerType": "any",
    "includeDetails": true,
    "businessOnly": false,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/yad2-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 = {
    "section": "vehicles",
    "vehicleType": "cars",
    "dealType": "forsale",
    "query": "ספה",
    "searchUrls": [],
    "manufacturers": [],
    "areas": [],
    "regions": [],
    "sellerType": "any",
    "includeDetails": True,
    "businessOnly": False,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/yad2-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 '{
  "section": "vehicles",
  "vehicleType": "cars",
  "dealType": "forsale",
  "query": "ספה",
  "searchUrls": [],
  "manufacturers": [],
  "areas": [],
  "regions": [],
  "sellerType": "any",
  "includeDetails": true,
  "businessOnly": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dami_studio/yad2-scraper --silent --output-dataset

```

## MCP server setup

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