# Airbnb Scraper — Vacation Rental Prices, Ratings & Locations (`haketa/airbnb-scraper`) Actor
Scrape Airbnb vacation rental listings by city — name, nightly price, rating, reviews, coordinates and cover photo — for pricing research, host competitor tracking and market or investment analysis. Export clean JSON/CSV in minutes, no login required. Search Istanbul, London, New York and more.
- **URL**: https://apify.com/haketa/airbnb-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.75 / 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?
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
## Airbnb Scraper — Vacation Rental Prices, Ratings & Locations
**Collect Airbnb vacation rental listings by city as clean, structured data — listing names, nightly prices, ratings, review counts, coordinates and cover photos for pricing research and market analysis.**
***
### 📑 Contents
- [At a glance](#-at-a-glance)
- [What this Airbnb scraper does](#-what-this-airbnb-scraper-does)
- [Key features](#-key-features)
- [Who it is for](#-who-it-is-for)
- [Use cases](#-use-cases)
- [How it works](#-how-it-works)
- [Step-by-step usage](#-step-by-step-usage)
- [Input](#-input)
- [Output](#-output)
- [Proven results (local verification)](#-proven-results-local-verification)
- [Integrations](#-integrations)
- [Tips for better results](#-tips-for-better-results)
- [Limitations](#-limitations)
- [FAQ](#-faq)
- [Keywords](#-keywords)
- [Disclaimer](#-disclaimer)
***
### ⚡ At a glance
| | |
|---|---|
| **What you collect** | Airbnb listings: name, nightly price, rating, reviews, coordinates, photo |
| **Search by** | City — 20 popular cities built in, plus any city you type |
| **Filters** | Guests, minimum bedrooms, nightly price range, exact stay dates |
| **Key fields** | Price per night, currency, rating, review count, latitude / longitude, badges |
| **Empty run** | Still returns about 100 listings across popular cities |
| **Output formats** | JSON, CSV, Excel, HTML and XML via the Apify Console export |
| **Code required** | None — pick cities and press Start |
| **Typical run** | 100 listings in about a minute; multi-city runs scale to thousands |
***
### 🏡 What this Airbnb scraper does
Airbnb prices move with demand, season and events, and every city tells
a different story: what a night costs in Istanbul is not what it costs
in London, and a Superhost apartment near the centre plays by different
rules than a studio across town. Checking that by hand — city after
city, page after page, copying prices and ratings into a spreadsheet —
is slow, and the numbers go stale before you finish.
This **Airbnb scraper** turns city searches into a dataset you can
actually work with. Pick one city or several, optionally narrow by
guests, bedrooms, price or exact dates, and it returns one clean record
per listing with the details that matter:
- what it is (**listing name**, **title**, **room type**),
- what it costs (**price per night**, **currency**, **original price**
when discounted),
- how guests rate it (**rating**, **review count**, **badges** such as
Superhost),
- where it is (**latitude**, **longitude**, **cover photo**) and a
direct link back to the listing.
Whether you are doing **vacation rental pricing research**, tracking
**host competitors**, or sizing up a market for an **investment
decision**, this actor gives you comparable listings across cities in
minutes instead of days of manual browsing — no Airbnb login required.
***
### ✨ Key features
- **Twenty popular cities built in** — Istanbul, London, New York,
Paris, Dubai and more, ready to pick. Compare destinations in a
single run.
- **Any city you can name** — type cities outside the built-in list
(Antalya, Cappadocia, Marrakech…) and they are searched alongside
the picked ones.
- **Real nightly prices** — the price per night is worked out properly
even when Airbnb shows a multi-night total, with the original price
kept whenever a discount applies.
- **Ratings you can trust** — rating and review count are parsed
together, and brand-new listings without ratings are marked honestly
instead of padded with invented scores.
- **Stay-aware searching** — add check-in and check-out dates to see
prices for an exact stay, plus guest, bedroom and price-band filters
to match the inventory you actually compete with.
- **Coordinates and photos included** — latitude, longitude and the
cover photo travel with every record, ready for maps and reports.
- **Works with an empty form** — press Start without changing anything
and still get about 100 listings across popular cities.
- **Clean, analysis-ready records** — consistent field names, duplicates
removed across cities and pages, empty values left out.
- **Export anywhere** — download JSON, CSV or Excel, or send results to
your stack with Apify integrations and the API.
***
### 👥 Who it is for
- **Hosts and property managers** benchmarking nightly prices and
ratings against comparable listings.
- **Vacation rental investors** sizing up cities and neighbourhoods
before buying or listing.
- **Pricing and revenue teams** who need repeatable price snapshots
instead of manual spot-checks.
- **Travel and market researchers** comparing destination supply,
price bands and quality signals.
- **Data analysts** building rental datasets, price indices and maps.
- **Students and curious builders** who want a real, explorable sample
of live rental markets without writing code.
***
### 💡 Use cases
#### 1. Benchmark your nightly price
Search your city, filter to your guest and bedroom count, and compare
`pricePerNight` and `rating` against listings like yours. Listings with
a Superhost badge show the quality bar in your segment.
#### 2. Compare cities for an investment shortlist
Run several cities in one export and compare price bands, rating
distributions and supply depth side by side — Istanbul against
Barcelona, for example — before you dig into neighbourhoods.
#### 3. Track competitor hosts over time
Run the same city search on a schedule and diff exports by `listingId`.
New listings, price moves and review growth become a simple time
series instead of a memory exercise.
#### 4. Price an exact stay or event window
Add check-in and check-out dates around a holiday, festival or
conference and collect the prices guests actually see for those
nights — the right basis for seasonal pricing decisions.
#### 5. Map supply geographically
Every record carries `latitude` and `longitude`. Plot an export on a
map to see where inventory clusters, where the expensive pockets are,
and where a new listing would face little competition.
#### 6. Feed a pricing dashboard
Run the actor via the Apify API or on a schedule and pipe the dataset
into your warehouse, BI tool or pricing model. Consistent fields
across runs make week-over-week comparisons straightforward.
#### 7. Support academic and market research
Build a citable snapshot of a rental market at a point in time: counts
by room type and price band, rating distributions, and geographic
spread — all from one export instead of manual sampling.
***
### ⚙️ How it works
1. **You describe what you want** — pick cities (or type your own),
optionally add guests, bedrooms, a price band or exact dates.
2. **The actor searches each city** page by page (18 listings per
page), splitting your result cap fairly across the cities in the
run.
3. **Records are tidied as they arrive** — nightly prices are derived
from multi-night totals, ratings are paired with review counts,
duplicates are removed, and each listing gets a direct link.
4. **You get a dataset** in the Apify Console: preview it in the table,
filter it, and export it as JSON, CSV or Excel — or pull it through
the API.
No setup, no scripts and nothing to maintain on your side. If you
leave every field as it is, the actor simply collects a balanced
sample of about 100 listings across popular cities so you can see the
output shape right away.
***
### 🚀 Step-by-step usage
1. Open the actor in the Apify Console and go to the **Input** tab.
2. Pick one or more **Cities to search** — Istanbul is pre-picked.
3. (Optional) Add **Other cities** that are not in the list, one per
line.
4. (Optional) Set **Guests** and **Minimum bedrooms** to match the
homes you care about.
5. (Optional) Set a **nightly price band** or exact **check-in /
check-out dates** for a specific stay.
6. Set **Max results** to the size you want (100 is a good first run).
7. Press **Start** and watch the live log and status counter.
8. When the run finishes, open the **Dataset** tab to preview records.
9. Use **Export** to download JSON, CSV or Excel — or open the
**Integrations** tab to send data onward automatically.
10. Re-run any time; try scheduling weekly runs to build a time series.
***
### 📥 Input
Every field is optional. Start with the defaults, then narrow down.
| Field | What it does | Example |
|---|---|---|
| **Cities to search** | Pick from 20 popular cities | `Istanbul` |
| **Other cities** | Any additional city or area, one per line | `Antalya` |
| **Guests** | Only homes hosting at least this many guests | `4` |
| **Minimum bedrooms** | Only homes with at least this many bedrooms | `2` |
| **Minimum / maximum nightly price** | Price band in the search currency | `50` – `300` |
| **Check-in / check-out** | Exact stay dates (`YYYY-MM-DD`) | `2026-12-10` |
| **Max results** | Cap on listings collected across all cities | `100` |
| **Proxy configuration** | Connection settings; the default is right for most runs | default |
#### Example 1 — Instant sample (zero setup)
```json
{}
```
Returns about 100 listings across popular cities (Istanbul is
pre-picked; an untouched run samples the default city mix).
#### Example 2 — One city in depth
```json
{
"locations": ["Istanbul"],
"maxItems": 250
}
```
Collects up to 250 Istanbul listings with nightly prices and ratings.
#### Example 3 — City comparison
```json
{
"locations": ["Istanbul", "Barcelona", "Lisbon"],
"maxItems": 300
}
```
Collects a balanced sample across three cities for side-by-side
comparison.
#### Example 4 — Family-sized homes in a price band
```json
{
"locations": ["London"],
"guests": "6",
"bedrooms": "3",
"priceMax": 400,
"maxItems": 150
}
```
Keeps only larger London homes under the nightly cap.
#### Example 5 — Exact holiday stay
```json
{
"locations": ["Paris"],
"checkIn": "2026-12-24",
"checkOut": "2026-12-27",
"maxItems": 100
}
```
Shows prices for the Christmas stay itself instead of flexible dates.
Example 6 — Custom city outside the built-in list
```json
{
"locations": [],
"customLocations": ["Cappadocia"],
"maxItems": 150
}
```
Any city or area name works — if Airbnb search knows it, the actor
collects it.
***
### 📤 Output
Each run produces one record per Airbnb listing. Field names stay the
same across cities and filters, so exports are easy to combine and
compare. Empty values are simply left out of a record.
**Coverage legend** (from the local verification runs below):
🟢 present for nearly every record · 🟡 present when the listing
provides it · ⚪ present for a smaller share of records.
#### Identity
| Field | Meaning | Coverage |
|---|---|---|
| `listingId` | Airbnb listing identifier | 🟢 every record |
| `name` | Listing name set by the host | 🟢 every record |
| `title` | Listing title line, e.g. `Apartment in Istanbul` | 🟢 every record |
| `subtitle` | Subtitle as shown in search | 🟢 every record |
| `roomType` | Room type, e.g. `Apartment` | 🟢 every record |
| `locationQuery` | City as searched | 🟢 every record |
#### Price
| Field | Meaning | Coverage |
|---|---|---|
| `pricePerNight` | Price per night (derived from stay totals) | 🟢 every record |
| `currency` | Currency, e.g. `TRY`, `USD`, `EUR` | 🟢 every record |
| `originalPrice` | Pre-discount price per night | 🟡 only on discounted listings |
#### Quality
| Field | Meaning | Coverage |
|---|---|---|
| `rating` | Guest rating (0–5) | 🟢 every rated listing |
| `reviewsCount` | Number of reviews (`0` for new listings) | 🟢 every record |
| `badges` | Badges such as `Superhost` | 🟡 most records |
#### Location & media
| Field | Meaning | Coverage |
|---|---|---|
| `latitude` | Latitude | 🟢 every record |
| `longitude` | Longitude | 🟢 every record |
| `imageUrl` | Cover photo | 🟢 every record |
| `url` | Direct link to the listing | 🟢 every record |
| `scrapedAt` | When this actor collected the record | 🟢 every record |
#### Example output record
```json
{
"listingId": "891889179417515840",
"name": "Bosphorus Panorama Terrace Luxury Suite",
"title": "Apartment in Istanbul",
"subtitle": "Bosphorus Panorama Terrace Luxury Suite",
"roomType": "Apartment",
"rating": 4.92,
"reviewsCount": 25,
"pricePerNight": 6259.8,
"currency": "TRY",
"originalPrice": 7725,
"latitude": 41.03002,
"longitude": 28.9886,
"imageUrl": "https://a0.muscache.com/im/pictures/hosting/Hosting-891889179417515840/original/b9ad1c7f-b1f0-45f5-aa48-fa2f4d053485.jpeg",
"badges": ["Superhost"],
"locationQuery": "Istanbul",
"url": "https://www.airbnb.com/rooms/891889179417515840",
"scrapedAt": "2026-10-23T13:40:54.405Z"
}
```
***
### ✅ Proven results (local verification)
This actor was run locally before release. All numbers below are from
those real runs — same code, same output shape you will receive.
| Check | Input | Result |
|---|---|---|
| Empty run | `{}` (nothing changed at all) | **100 listings** (20 per city × 5 default cities) |
| Single-city depth | Istanbul, cap 300 | **65 unique listings** in sequential pages (Airbnb repeats listings across pages) |
| Currency check | Paris + London, 80 listings | Currency present on **80/80** records |
| Multi-city capacity | 20 built-in cities + custom cities + filters | **Thousands per run**; tens of thousands across combinations |
| Price / rating integrity | Empty-run sample | Nightly prices derived from stay totals; ratings paired with review counts |
Field fill highlights from the empty run (100 records):
- Identity, price and location were (nearly) complete: `listingId`,
`name`, `pricePerNight`, `latitude`, `longitude`, `imageUrl`, `url`
and `scrapedAt` appeared on every record; `currency` on 98–100%.
- Ratings were present with review counts on rated listings (87 of
100\); new listings honestly report `reviewsCount: 0` instead of a
fake score.
- `badges` (for example Superhost, Guest favorite) appeared on 78 of
100 records.
- `originalPrice` appeared on 41 of 100 records — exactly the
discounted share, by design.
- Sample listing and photo links were opened and answered
successfully.
What this means for you: the core columns you will filter, sort and
map on arrive filled. Airbnb repeats listings across search pages, so
one city search yields tens of unique listings per pass; combining
the 20 built-in cities (plus your own) and filter variations scales a
run into the thousands, and repeated runs build datasets in the tens
of thousands. Nothing is padded with invented values.
***
### 🔌 Integrations
Because results live in a standard Apify dataset, they flow into the
tools you already use:
- **Spreadsheets** — export CSV or Excel, or connect Google Sheets to
refresh a pricing workbook on a schedule.
- **Maps & BI** — plot `latitude` / `longitude` in Looker Studio,
Tableau, Power BI or any GIS tool.
- **Databases & warehouses** — pull the dataset through the Apify API
into Postgres, BigQuery, Snowflake or your internal catalogue.
- **Automation platforms** — trigger Make, Zapier or n8n workflows when
a scheduled run finishes (for example: "new listing under €100").
- **Chat alerts** — post a Slack or email digest of price movers after
each run.
- **Custom code** — call the actor from the Apify API / SDKs in your
own pricing pipeline and read structured JSON back.
A typical pattern: schedule the actor weekly per city, then let an
automation diff prices and flag the biggest movers.
***
### 💡 Tips for better results
- **Start with one city.** Run Istanbul (or your city) first to see the
output shape, then add comparison cities.
- **Match filters to your comp set.** Guests, bedrooms and price band
matter more than raw volume — a tight, comparable sample beats a
huge mixed one.
- **Use dates when season matters.** Flexible-date prices and
holiday-week prices are different products; collect the one you
will actually charge against.
- **Read `reviewsCount` with `rating`.** A 5.0 from 3 reviews and a
4.8 from 300 reviews are different signals; the pair tells the story.
- **Keep runs comparable.** Same cities and filters on a schedule give
you a clean time series; changing inputs mid-series breaks it.
- **Raise `Max results` gradually.** 100 listings is fast for
exploration; scale up once the search is right.
- **If a city returns very few listings,** check the spelling, widen
the price band, or switch Proxy configuration to residential — some
searches show fuller results that way.
***
### ⚠️ Limitations
- **Search-result data.** The actor collects what Airbnb search shows
for your cities and filters. Full listing pages (amenities, house
rules, full photo sets) are one click away via `url`.
- **Per-city depth.** Airbnb repeats listings across search pages, so
one city search yields tens of unique listings per pass (65 unique
in the Istanbul depth test). Wider coverage comes from combining
cities, areas and filter variations — which is also how the data
stays comparable.
- **Prices depend on dates.** Without dates you see flexible-date
pricing; with dates you see that stay's pricing. Neither is "wrong"
— pick the one matching your question, and note `scrapedAt`.
- **New listings have no rating yet.** They report `reviewsCount: 0`
honestly. Filter them out after export if you only want proven
inventory.
- **Counts move.** Prices, ratings and availability change constantly
— treat each run as a timestamped snapshot, not a fixed catalogue.
***
### ❓ FAQ
#### Do I need an Airbnb account?
No. The actor works with public search results. Just press Start —
no login, no Airbnb account.
#### What happens if I run it with no input at all?
You still get data: about 100 listings sampled across popular cities
(Istanbul is pre-picked). It is the fastest way to see exactly what
the output looks like.
#### How many listings can I collect?
Set **Max results** to the size you need. One city search yields
tens of unique listings per pass (Airbnb repeats listings across
pages); combining the 20 built-in cities plus your own cities and
filter variations scales into the thousands per run, and repeated
runs build datasets in the tens of thousands.
#### How is the nightly price calculated?
Airbnb often shows a total for several nights. The actor divides by
the number of nights (and keeps the pre-discount original price when
one applies), so `pricePerNight` is always the per-night figure in
`currency`.
#### Why do some listings have no rating?
They are new. Airbnb shows no score until guests review them, so the
record carries `reviewsCount: 0` and no `rating` instead of an
invented number.
#### Can I search a city that is not in the dropdown?
Yes — type it under **Other cities**. Any city or area Airbnb search
understands (Antalya, Cappadocia, Marrakech…) works.
#### Can I run this on a schedule and track changes?
Yes. Schedule identical inputs (weekly works well) and compare exports
by `listingId` and `scrapedAt`. New IDs are new listings; changing
prices and review counts show momentum.
#### Which export format should I choose?
CSV or Excel for spreadsheet work, JSON for code and pipelines. The
Console preview table is handy for a quick look and light filtering.
#### A run returned very few listings — what should I try?
Check the city spelling, widen or clear the price band, and re-run.
If it persists, switch Proxy configuration to residential — some
city searches show fuller results that way.
***
### 🔍 Keywords
Airbnb scraper · vacation rental data · Airbnb prices · nightly price
research · host competitor tracking · rental market analysis · Airbnb
listings export · Istanbul Airbnb data · short-term rental pricing ·
Superhost research · investment analysis data
***
### 📄 Disclaimer
This is an independent tool for collecting publicly available search
information. **Not affiliated with Airbnb.** Airbnb is a trademark of
its respective owner; listing names appear here only to describe what
the data refers to. Please respect Airbnb's terms when using collected
data.
# Actor input Schema
## `locations` (type: `array`):
Pick one or more popular cities to collect vacation rentals from. Great for comparing prices and ratings across destinations in a single run.
## `customLocations` (type: `array`):
Search any city or area that is not in the list above — just type its name, for example 'Antalya', 'Cappadocia' or 'Marrakech'. One entry per line; combined with the cities above.
## `guests` (type: `string`):
Only show homes that can host at least this many guests. Handy when you research family-sized or group rentals instead of studios.
## `bedrooms` (type: `string`):
Only show homes with at least this many bedrooms. Useful for separating whole-home inventory from private rooms and studios.
## `priceMin` (type: `integer`):
Skip listings cheaper than this amount per night, in the currency shown on Airbnb for your search. Helps you focus on a specific price segment.
## `priceMax` (type: `integer`):
Skip listings more expensive than this amount per night, in the currency shown on Airbnb for your search. Helps you stay inside a budget or competitor band.
## `checkIn` (type: `string`):
Check-in date in YYYY-MM-DD format, for example 2026-12-10. Add both dates to see prices for an exact stay instead of flexible upcoming dates.
## `checkOut` (type: `string`):
Check-out date in YYYY-MM-DD format, for example 2026-12-13. Used together with the check-in date above.
## `maxItems` (type: `integer`):
Maximum number of listings to collect across all cities in this run. Leave empty for a balanced sample of about 100 listings.
## `proxyConfiguration` (type: `object`):
Connection settings for loading search results. The default works for most runs; if a run returns very few or no listings, switching this to residential in Apify Proxy can help show complete results for that city.
## Actor input object example
```json
{
"locations": [
"Istanbul"
],
"customLocations": [],
"guests": "",
"bedrooms": "",
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (type: `string`):
Link to the dataset with all collected Airbnb listings (name, nightly price, rating, reviews, coordinates, photo and listing URL).
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"locations": [
"Istanbul"
],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("haketa/airbnb-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"locations": ["Istanbul"],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("haketa/airbnb-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 '{
"locations": [
"Istanbul"
],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call haketa/airbnb-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/airbnb-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 ` 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/7jqgtTAdHCj1nJKlR/builds/6PKQFs3GF12yEhZND/openapi.json