# Bien'ici Property Scraper (`axiomworks/bienici-property-listings-scraper`) Actor

Collect Bien'ici listings for rent or purchase and get fields such as price, surface area, rooms, city, postal code, description, energy and greenhouse-gas classes, photos and coordinates. Choose property types and filters, with an option to fetch additional details for each listing.

- **URL**: https://apify.com/axiomworks/bienici-property-listings-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.98 / 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

**Returns:** one row per property listing with id, sourceUrl, price, surfaceArea, bedroomsQuantity, city, and energyClassification.
**Input:** `{"places": ["Lyon"], "transactionType": "rent", "propertyTypes": ["flat"], "maxItems": 30}`
**Best for:** real-estate market research, rental and price monitoring, lead and comparable lists for France.

```json
{
  "id": "ag335407-494683130",
  "sourceUrl": "https://www.bienici.com/annonce/ag335407-494683130",
  "transactionType": "buy",
  "propertyType": "flat",
  "price": 49000,
  "surfaceArea": 7,
  "city": "Bordeaux",
  "energyClassification": "NS"
}
```

### What does Bienici Property Listings Scraper do?

Bienici Property Listings Scraper is a Bien'ici scraper and Bien'ici API alternative. Supply French place names or search URLs, choose buy or rent, and collect prices, surface, rooms, location, descriptions, energy classes and photos. It reads public JSON without login or a browser. Details are off by default.

Use `listingIds` or `listingUrls` to refresh specific properties. Direct targets run first, share `maxItems` with searches, and fetch details once per unique ID. Unavailable targets are skipped without placeholder rows. Direct URLs support /annonce/<id>, /annonce/<location>/<id>, and realEstateAd.json?id=<id>; search filters do not restrict direct targets.

- Build lists of flats and houses for sale or rent in any French city.
- Track asking prices and price per square metre over time for a neighbourhood.
- Compare energy performance classes across a market.
- Feed listings, photos and coordinates into a database, spreadsheet or map.

Large searches are split into price bands to work around the source offset limit. Records are merged without duplicate IDs.

This Actor is independent and is not affiliated with or endorsed by Bien'ici.

### What data can you get?

Each record is one listing. Fields that a listing does not provide are returned as null.

| Field | Type | Description |
|---|---|---|
| `id` | string | Bien'ici listing identifier, unique per record. |
| `sourceUrl` | string | Listing page on Bien'ici. |
| `title` | string | Listing title (seller-provided, or generated when details are included); often empty. |
| `transactionType` | string | buy or rent. |
| `propertyType` | string | flat, house, parking, shop, etc. |
| `price` | number | Price in euros (monthly rent for rentals). |
| `pricePerSquareMeter` | number | Price divided by surface area. |
| `surfaceArea` | number | Surface in square metres. |
| `roomsQuantity` | number | Number of rooms. |
| `bedroomsQuantity` | number | Number of bedrooms. |
| `city` | string | City or arrondissement name. |
| `postalCode` | string | French postal code. |
| `district` | string | Neighbourhood name. |
| `description` | string | Full listing description in French. |
| `energyClassification` | string | DPE energy class A-G. |
| `greenhouseGazClassification` | string | GES class A-G. |
| `accountType` | string | Advertiser type: agency, network, owner... |
| `agencyName` | string | Advertiser name: from details for direct targets or when includeDetails is true, otherwise the display name in the search result when the advertiser gives one. |
| `photos` | array | Photo URLs on file.bienici.com. |
| `publishedAt` | string | Publication date (ISO); falls back to the last modification date when the listing has no real publication date, null if neither is known. |
| `modifiedAt` | string | Last modification date (ISO). |
| `priceWithoutFees` | number | Asking price excluding agency fees, copied from the listing when provided. |
| `agencyFeePercentage` | number | Advertised agency fee percentage; null when not provided. |
| `feesChargedTo` | string | Source code identifying who pays agency fees, such as purchaser or seller. |
| `isInCondominium` | boolean | Whether the listing is explicitly marked as part of a condominium. |
| `annualCondominiumFees` | number | Advertised annual condominium fees in euros, when provided. |
| `condominiumPartsQuantity` | number | Advertised number of condominium parts or lots; not the room count. |
| `isCondominiumInProcedure` | boolean | Whether the listing explicitly reports a condominium procedure. |
| `landSurfaceArea` | number | Advertised plot or land area in square metres; separate from living area. |
| `hasGarden` | boolean | Whether the listing explicitly reports a garden. |
| `hasPool` | boolean | Whether the listing explicitly reports a pool. |
| `hasTerrace` | boolean | Whether the listing explicitly reports a terrace. |
| `energyPerformanceDiagnosticDate` | string | DPE diagnostic date as supplied by Bien’ici; null when not provided. |
| `useJuly2021EnergyPerformanceDiagnostic` | boolean | Source flag indicating use of the July 2021 DPE method; no legal assessment is inferred. |
| `latitude` | number | Blurred latitude of the listing. |
| `longitude` | number | Blurred longitude of the listing. |
| `yearOfConstruction` | number | Advertiser-reported construction year, nullable. |
| `floorQuantity` | number | Source-reported number of floors, nullable. |
| `terracesQuantity` | number | Source-reported terrace count, nullable. |
| `greenhouseGazValue` | number | Source-reported numeric greenhouse emissions, nullable. |
| `reference` | string | Advertiser reference. |
| `floor` | number | Floor number. |
| `hasElevator` | boolean | Whether the building has an elevator. |
| `isFurnished` | boolean | Whether the property is furnished. |
| `newProperty` | boolean | Whether it is a new build. |
| `monthlyCharges` | number | Monthly charges in euros (rentals). |
| `agencyRentalFee` | number | Rental agency fee in euros, when the listing supplies it. |
| `inventoryOfFixturesFees` | number | Inventory of fixtures fee in euros, when supplied. |
| `safetyDeposit` | number | Rental security deposit in euros, when supplied. |
| `bathroomsQuantity` | number | Number of bathrooms. |
| `parkingPlacesQuantity` | number | Number of parking places. |
| `balconyQuantity` | number | Number of balconies. |
| `priceHasDecreased` | boolean | Whether Bien'ici marks a price decrease. |
| `energyValue` | number | Energy consumption value reported with the DPE class. |

The dataset also includes the nullable fields `availableDate`, `rentWithoutCharges`, `showerRoomsQuantity`, `toiletQuantity`, `heating`, `exposition`, `hasBalcony`, `hasCellar`, `isStudio` and `flatSharing`, copied from the same response. They are null when the advertiser did not state them.

The sale-price fields `priceWithoutFees`, `agencyFeePercentage` and `feesChargedTo` help compare advertised amounts and fee responsibility. Condominium records can include `isInCondominium`, `annualCondominiumFees`, `condominiumPartsQuantity` and `isCondominiumInProcedure`. Annual fees are distinct from rental `monthlyCharges`; missing values remain null, including missing boolean flags. The source may contain unusual figures, so verify an advertisement before relying on its financial details.

Outdoor fields `landSurfaceArea`, `hasGarden`, `hasPool` and `hasTerrace` distinguish plot area from living area and describe explicitly supplied amenities. `energyPerformanceDiagnosticDate` preserves the source date, while `useJuly2021EnergyPerformanceDiagnostic` preserves its diagnostic-method flag. These fields are copied from public listing JSON without extra detail requests and can be absent for individual properties. They describe the advertisement rather than certifying building condition, legal compliance or the availability of an amenity.

### How to use

1. Open the Actor and type one or more places into **Places**, such as `Lyon`. Place names are resolved to Bien'ici zones automatically, including arrondissements like `Lyon 3e`.
2. Choose **Transaction type**: buy or rent.
3. Choose **Property types**, for example flat and house.
4. Optionally set price, surface, room or bedroom bounds. For rental research, **Furnished only** limits results to listings marked furnished.
5. Set **Max items** to the number of listings you want. The Actor stops at that shared total across all places and URLs, or sooner if fewer listings match or your spending limit is reached.
6. Press Start and download the dataset as JSON, CSV, Excel or via the API.

You can also paste Bien'ici search URLs into **Start URLs**. The place, transaction type, property type and price or surface bounds are read from the URL. If a place name cannot be found, it is skipped. If no target returns listings, the run succeeds with zero records and a status message suggesting another place, a search URL, or less restrictive filters. A malformed URL or missing target fails input validation. A failed target does not prevent other targets from running.

For search targets, turn on **Include details** to make one extra request per listing and add the advertiser name (`agencyName`) and a generated title when the seller left the title empty. This is slower, so leave it off when you only need the search data.

### Input

| Field | Type | Description |
|---|---|---|
| `places` | array of strings | Places to search, e.g. "Lyon". Required by the schema; use \[] for a URL-only search. |
| `startUrls` | array | Optional bienici.com search URLs. |
| `transactionType` | string | `buy` or `rent`. Default buy. |
| `propertyTypes` | array | flat, house, parking, shop, loft, castle, building, office, terrain. Default flat and house. |
| `maxItems` | integer | Shared maximum across all places, URLs and pages. Default 50. |
| `minPrice`, `maxPrice` | integer | Price bounds in euros (monthly rent when renting). |
| `minArea`, `maxArea` | integer | Surface bounds in square metres. |
| `minRooms`, `maxRooms` | integer | Room count bounds. |
| `minBedrooms`, `maxBedrooms` | integer | Bedroom count bounds. Leave empty for no bound. |
| `furnishedOnly` | boolean | Return only listings marked furnished. Default false. |
| `includeDetails` | boolean | Add agencyName and a generated title with one extra request per listing. Default false. |
| `proxyConfiguration` | object | Apify Proxy settings. Default is no proxy, with automatic fallback when requests are blocked. |
| `listingIds` | array of strings | Direct IDs; default empty. Use places: \[] for IDs only. |
| `listingUrls` | array of URLs | Direct public listing links, as strings or URL objects; default empty. |

Direct target example:

```json
{"places": [], "listingIds": ["immo-facile-61288997"], "maxItems": 1}
```

Example input:

```json
{
  "places": ["Bordeaux"],
  "transactionType": "buy",
  "propertyTypes": ["house", "flat"],
  "minBedrooms": 2,
  "maxPrice": 600000,
  "maxItems": 50
}
```

### Output

The dataset has one item per listing. Fields from a public Bordeaux search response fetched locally on 15 October 2026:

```json
{
  "id": "ag335407-494683130",
  "sourceUrl": "https://www.bienici.com/annonce/ag335407-494683130",
  "transactionType": "buy",
  "propertyType": "flat",
  "price": 49000,
  "surfaceArea": 7,
  "city": "Bordeaux",
  "energyClassification": "NS",
  "priceWithoutFees": 49000,
  "agencyFeePercentage": null,
  "feesChargedTo": "seller",
  "isInCondominium": true,
  "annualCondominiumFees": 120,
  "condominiumPartsQuantity": null,
  "isCondominiumInProcedure": false,
  "landSurfaceArea": null,
  "hasGarden": null,
  "hasPool": false,
  "hasTerrace": false,
  "energyPerformanceDiagnosticDate": "2025-12-05",
  "useJuly2021EnergyPerformanceDiagnostic": true
}
```

Notes on the data:

- Prices are in euros. For rentals the price is the monthly rent.
  Bedroom and furnishing filters apply to searches; missing source attributes can exclude a listing.
- The latitude and longitude are the blurred position published by the site, not the exact address.
- Some imported listings carry no real publication date; `publishedAt` then uses the last modification date, or is null if that is missing too.
  Advertiser names can come from search display names or details. Phone numbers are not collected.

### How much does it cost?

You are charged per result, which means per listing saved to the dataset. Runs that return nothing do not charge for results. See the Pricing tab of the Actor for the current rate, and set **Max items** to cap what a run can cost. A spending-limit stop is shown in the final run status; increase that limit only when you want more records.

### Use with AI agents (MCP)

For a URL-only tool call, send `places: []` and a `startUrls` array containing strings or URL objects. When both targets are supplied, both are searched under the same `maxItems` total. Keep `includeDetails: false` for a quick initial sample. A zero-record success is not evidence that a city has no property listings: inspect the run status and logs, check spelling, relax filters, or retry blocked requests with Apify Proxy.

You can call this Actor from any MCP-capable assistant through the Apify MCP server. Add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=axiomworks/bienici-property-listings-scraper"
    }
  }
}
```

Example prompts:

- "Find 30 flats to rent in Lyon with their price, surface and energy class."
- "List houses for sale in Bordeaux under 600000 euros with surface and rooms."
- "Compare the average price per square metre of listings in Paris 11e and Paris 15e."

### Integrations and API

Call the Actor with the Apify client.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("axiomworks/bienici-property-listings-scraper").call(run_input={
    "places": ["Lyon"],
    "transactionType": "rent",
    "propertyTypes": ["flat"],
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["city"], item["price"], item["surfaceArea"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('axiomworks/bienici-property-listings-scraper').call({
    places: ['Lyon'],
    transactionType: 'rent',
    propertyTypes: ['flat'],
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((i) => process.stdout.write(`${i.city} ${i.price}\n`));
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~bienici-property-listings-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"places": ["Lyon"], "transactionType": "rent", "propertyTypes": ["flat"], "maxItems": 50}'
```

Use the Integrations tab for spreadsheets, webhooks and scheduled runs.

### FAQ

**How many listings can I get?** As many as match your search. Searches that match more listings than a single query can return are split by price automatically. Set `maxItems` to the number you need.

**Why is the title empty on some listings?** Many advertisers leave the title blank. Enable **Include details** to get a generated title in those cases, otherwise the field is null.

**Does it return the agency name or phone number?** The agency name is available for direct listing targets or with **Include details**. Phone numbers are not collected.

**Why does publishedAt sometimes equal modifiedAt?** Listings imported from agency software often have no real publication date, so the last modification date is used instead of a placeholder. If neither date exists the value is null.

**Can I search a whole department or region?** Use place names that Bien'ici resolves to a zone, such as a city, arrondissement or department name, or paste a Bien'ici search URL.

**What happens with a place that does not exist?** The Actor logs a warning, and if nothing usable remains the run succeeds with zero records and guidance to change the place or filters. Blocked targets are logged and skipped after retries; try enabling proxyConfiguration or a different place. Other targets continue.

**Does it need a proxy?** Usually not. With the default configuration, requests go directly first and retry through Apify datacenter Proxy when blocked or rate limited. If you supply proxy settings, retries keep those settings and use fresh sessions. Persistent blocks yield no placeholder records and the run succeeds with guidance.

### Is it legal to scrape Bien'ici?

The Actor collects only data that is publicly visible on Bien'ici without logging in, at a modest request rate of about two requests per second. It does not bypass logins or CAPTCHAs. Listing text and photos can be protected by copyright and database rights, and listings can contain personal data, so use the output in line with the website's terms, French and EU law including GDPR, and your own legal advice. You are responsible for how you use the data.

### Feedback

Found a bug or missing field? Open an issue from the Actor page and include the input you used.

# Actor input Schema

## `places` (type: `array`):

French city, arrondissement or department names as strings, e.g. \["Lyon", "Paris 11e"]. Required in the schema; pass \[] when using startUrls, listingIds or listingUrls only. Unresolved places are skipped; if no target matches, the run succeeds with 0 records and guidance. No API default.

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

Bien’ici search URLs as strings or {"url":"https://www.bienici.com/recherche/location/lyon-69000/appartement"} objects. Default no URLs. For URL-only searches send places: \[]. URL transaction, property and price/surface filters override corresponding input filters; places and URLs both run when supplied.

## `transactionType` (type: `string`):

Choose "buy" for sale listings or "rent" for rentals, e.g. "rent". Default "buy" searches sales. A transaction encoded in a startUrls search overrides this choice for that URL.

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

List of property codes, e.g. \["flat", "house"]. Allowed: flat, house, parking, shop, loft, castle, building, office, terrain. Default \["flat", "house"] returns apartments and houses. URL property types override this list for that URL.

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

Positive whole number of unique listings to save, e.g. 30; default 50. One shared limit across all places, URLs and pages, not a limit per target. Fewer records are returned when matches run out or the spending limit is reached.

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

Positive integer lower bound in euros; monthly rent for rent searches, e.g. 1000. Applies with the other filters; minPrice should not exceed maxPrice.

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

Positive integer upper bound in euros; monthly rent for rent searches, e.g. 1000. Applies with the other filters; minPrice should not exceed maxPrice.

## `minArea` (type: `integer`):

Positive integer lower bound in square metres, e.g. 40. Applies with the other filters; minArea should not exceed maxArea.

## `maxArea` (type: `integer`):

Positive integer upper bound in square metres, e.g. 40. Applies with the other filters; minArea should not exceed maxArea.

## `minRooms` (type: `integer`):

Positive integer lower bound in rooms, e.g. 2. Applies with the other filters; minRooms should not exceed maxRooms.

## `maxRooms` (type: `integer`):

Positive integer upper bound in rooms, e.g. 2. Applies with the other filters; minRooms should not exceed maxRooms.

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

Fetch one extra detail request per search listing for agencyName and title when available; default false. Direct listingIds/listingUrls already fetch details once regardless of this setting. Detail failures keep search data and leave unavailable fields null.

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

Apify proxy configuration; default {"useApifyProxy":false} sends direct requests with datacenter fallback when blocked. When configured, all retries retain your proxy settings with fresh sessions. Persistent blocks are skipped and the run succeeds with guidance.

## `minBedrooms` (type: `integer`):

Positive integer lower bound in bedrooms, e.g. 1. Applies with the other filters; minBedrooms should not exceed maxBedrooms.

## `maxBedrooms` (type: `integer`):

Positive integer upper bound in bedrooms, e.g. 1. Applies with the other filters; minBedrooms should not exceed maxBedrooms.

## `furnishedOnly` (type: `boolean`):

Boolean, e.g. true. Default false applies no furnishing filter. Set true to request only properties marked furnished by Bien’ici; useful with transactionType: "rent". Missing furnishing data may exclude a listing.

## `listingIds` (type: `array`):

Bien’ici listing IDs to fetch directly, e.g. \["immo-facile-61288997"]. Default empty. Pass places: \[] for IDs only. Direct targets run before searches, share maxItems, and unavailable or blocked targets are skipped without error records. Search filters do not restrict direct IDs.

## `listingUrls` (type: `array`):

Public Bien’ici listing URLs as strings or {"url":"https://www.bienici.com/annonce/immo-facile-61288997"} objects. Supports /annonce/<id>, /annonce/<location>/<id> and realEstateAd.json?id=<id>. Default empty. Pass places: \[] for URLs only. Direct targets run first, share maxItems and ignore search filters; unavailable or blocked listings are skipped.

## Actor input object example

```json
{
  "places": [
    "Lyon"
  ],
  "transactionType": "rent",
  "propertyTypes": [
    "flat"
  ],
  "maxItems": 30,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "furnishedOnly": false,
  "listingIds": [],
  "listingUrls": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per property listing.

# 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 = {
    "places": [
        "Lyon"
    ],
    "transactionType": "rent",
    "propertyTypes": [
        "flat"
    ],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/bienici-property-listings-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 = {
    "places": ["Lyon"],
    "transactionType": "rent",
    "propertyTypes": ["flat"],
    "maxItems": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/bienici-property-listings-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 '{
  "places": [
    "Lyon"
  ],
  "transactionType": "rent",
  "propertyTypes": [
    "flat"
  ],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/bienici-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/bienici-property-listings-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/05a7ap57ztP5vyGLx/builds/CG8hVejlEPePcTbse/openapi.json