# Pappers.fr Company Scraper (`parsebird/pappers-scraper`) Actor

Scrape French company data from Pappers.fr — SIREN, legal form, address, directors, financials, and establishments. Search by keyword or paste pappers.fr/recherche URLs with filters. Export as JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/pappers-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 company scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Pappers.fr Company Scraper

Extract structured French company data from [Pappers.fr](https://www.pappers.fr) — France's comprehensive free business directory. Search by keyword or paste filtered search URLs to get SIREN numbers, legal forms, addresses, directors, establishments, and activity codes in bulk.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by keyword, department, city, NAF code, legal status, and 15+ other filters — extract complete French company profiles with directors, establishments, and financial data ready for CRM import, lead generation, or market analysis.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Pappers.fr Company Scraper (parsebird/pappers-scraper) extracts French company data from Pappers.fr. Call via ApifyClient: client.actor("parsebird/pappers-scraper").call(run\_input={"searchUrls": \["https://www.pappers.fr/recherche?q=COMPANY"], "queries": \["keyword"], "maxResults": 100, "precision": "standard", "bases": "entreprises,dirigeants,publications"}). Inputs: searchUrls (array, pappers.fr/recherche URLs with filters), queries (array, keyword searches), maxResults (int, 0=unlimited), precision (standard|strict), bases (comma-separated: entreprises,dirigeants,publications). Output fields: siren, nom\_entreprise, denomination, forme\_juridique, capital, date\_creation, etat\_administratif, code\_naf, libelle\_activite, adresse (object), dirigeants (array), etablissements (array). Get API token: https://console.apify.com/account#/integrations. API docs: https://docs.apify.com/api/v2. Pricing: $3.99/1,000 results (standard), $1.99/1,000 (Gold plan).

````

### What does Pappers.fr Company Scraper do?

This Apify Actor searches and extracts French company data from Pappers.fr at scale — no API key required.

- 🔍 **Search by keyword** — Enter company names, industries, director names, or any term to find matching French companies
- 🌐 **Use Pappers.fr URL filters** — Build advanced searches on [pappers.fr/recherche](https://www.pappers.fr/recherche) (department, city, NAF code, legal status, revenue range, and more), copy the URL, and paste it in
- 📋 **Search multiple databases** — Find results across entreprises (companies), dirigeants (directors), and publications simultaneously
- 📈 **Unlimited results** — Automatic pagination through all matching companies using cursor-based navigation
- 🎯 **Precision control** — Choose between standard (broader) and strict (exact) matching
- 🔄 **Batch processing** — Run multiple queries and URLs in a single run with merged results
- 📦 **Export anywhere** — Download as JSON, CSV, Excel, or HTML directly from the Apify platform
- ⏰ **Schedule and automate** — Set up recurring runs via [Apify scheduling](https://docs.apify.com/platform/schedules) or trigger via [REST API](https://docs.apify.com/api/v2)

### What data can you extract from Pappers.fr?

Each company result includes a detailed profile with identification, legal structure, address, management, and establishment data.

| Data Field | Description |
|------------|-------------|
| **siren** | 9-digit unique company identifier (INSEE) |
| **nom_entreprise** | Company trade name |
| **denomination** | Official legal denomination |
| **forme_juridique** | Legal form (SARL, SAS, SA, EURL, etc.) |
| **capital** | Share capital in euros |
| **date_creation** | Company registration date |
| **etat_administratif** | Status: Active (A) or Ceased (C) |
| **code_naf** | NAF/APE activity code |
| **libelle_activite** | Activity description in French |
| **adresse** | Full address: street, postal code, city, country |
| **dirigeants** | Directors with name, first name, and role |
| **etablissements** | Establishments with SIRET, address, and active status |

### How to scrape Pappers.fr

1. **Open the Actor** — Go to [Pappers.fr Company Scraper](https://apify.com/parsebird/pappers-scraper) on Apify Console
2. **Enter search criteria** — Paste pappers.fr/recherche URLs, type keyword queries, or both
3. **Set your limit** — Choose how many results per query (or set to 0 for unlimited)
4. **Configure precision** — Select standard or strict matching for keyword searches
5. **Click Start** — The Actor automatically paginates through all matching results
6. **Download your data** — Export results as JSON, CSV, Excel, or HTML from the dataset tab

**Pro tip:** For the most targeted results, use the [Pappers.fr search page](https://www.pappers.fr/recherche) to visually build filters (department, NAF code, legal status, revenue range), then copy the resulting URL and paste it into the Search URLs field. All filter parameters are automatically preserved.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| searchUrls | array | No | [] | Pappers.fr search URLs with filter parameters |
| queries | array | No | [] | Keyword search terms |
| maxResults | integer | No | 100 | Max results per query/URL (0 = unlimited) |
| precision | string | No | "standard" | Search precision: standard or strict |
| bases | string | No | "entreprises,dirigeants,publications" | Databases to search (comma-separated) |

At least one `searchUrls` entry or `queries` entry is required.

### Output example

```json
{
  "siren": "503826968",
  "nom_entreprise": "AMD RENTAL",
  "denomination": "AMD RENTAL",
  "forme_juridique": "SARL",
  "forme_juridique_code": "5499",
  "capital": 10000,
  "date_creation": "2008-01-15",
  "date_radiation": null,
  "etat_administratif": "A",
  "etat_administratif_libelle": "Active",
  "code_naf": "77.11Z",
  "libelle_activite": "Location et location-bail d'automobiles et d'autres véhicules automobiles légers",
  "adresse": {
    "ligne": "12 Rue de la Paix",
    "code_postal": "75002",
    "ville": "Paris",
    "pays": "France"
  },
  "dirigeants": [
    {
      "nom": "Dupont",
      "prenom": "Jean",
      "fonction": "Gérant"
    }
  ],
  "etablissements": [
    {
      "siret": "50382696800015",
      "adresse": "12 Rue de la Paix, 75002 Paris",
      "actif": true
    }
  ]
}
````

Download results in **JSON, CSV, Excel, or HTML** directly from the [Apify dataset](https://docs.apify.com/platform/storage/dataset).

### How much does it cost to scrape Pappers.fr?

The Pappers.fr Company Scraper uses pay-per-event pricing — you only pay for results delivered, not compute time.

| Plan | Price per result | Price per 1,000 results |
|------|-----------------|------------------------|
| Free, Personal, Team | $0.00399 | **$3.99** |
| Gold | $0.00199 | **$1.99** |

One event = one company profile pushed to your dataset. You are not charged for Apify platform compute usage separately.

**Example:** Extracting 5,000 French companies in a specific department costs approximately $19.95 on the standard plan or $9.95 on the Gold plan.

New users get a [free trial](https://apify.com/pricing) with $5 of platform credits to test any Actor.

### Use cases

- **Lead generation** — Build targeted prospect lists of French companies by industry, location, or size
- **Market research** — Analyze business density, activity codes, and company demographics across French regions
- **Competitor monitoring** — Track new company registrations and status changes in your sector
- **KYC/compliance** — Verify company identities, directors, and legal status for due diligence
- **CRM enrichment** — Bulk-import French company data with SIREN/SIRET identifiers into your database
- **Academic research** — Study French business ecosystems, entrepreneurship patterns, and regional economics

### How it works

1. The Actor receives your search URLs and/or keyword queries
2. For URLs: filter parameters (department, NAF code, legal status, etc.) are extracted and forwarded to the Pappers.fr search API
3. For queries: keywords are searched with your chosen precision and database settings
4. Results are paginated automatically — page-based for small sets (≤400), cursor-based for larger or unlimited requests
5. Each company profile is normalized into a consistent schema and pushed to the Apify dataset
6. Pay-per-event charging applies per result delivered

### Programmatic API usage

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "searchUrls": ["https://www.pappers.fr/recherche?q=boulangerie&departement=75"],
    "queries": [],
    "maxResults": 100,
    "precision": "standard",
    "bases": "entreprises",
}

run = client.actor("parsebird/pappers-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['siren']} - {item['nom_entreprise']} ({item['forme_juridique']})")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<YOUR_API_TOKEN>" });

const input = {
    searchUrls: ["https://www.pappers.fr/recherche?q=boulangerie&departement=75"],
    queries: [],
    maxResults: 100,
    precision: "standard",
    bases: "entreprises",
};

const run = await client.actor("parsebird/pappers-scraper").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((item) => {
    console.log(`${item.siren} - ${item.nom_entreprise} (${item.forme_juridique})`);
});
```

Get your API token at [Apify Console → Integrations](https://console.apify.com/account#/integrations).

### Is it legal to scrape Pappers.fr?

The Pappers.fr Company Scraper accesses **publicly available company data** published through Pappers.fr's search interface. All data originates from French official registries (INSEE, Registre du Commerce et des Sociétés, BODACC) and is legally diffusable public information.

This Actor does not access private accounts, bypass authentication, or collect non-diffusable personal data. It uses the same public search interface available to any visitor of pappers.fr.

As with any data collection tool, users should review [Pappers.fr's terms of service](https://www.pappers.fr/mentions-legales) and ensure their specific use case complies with applicable regulations, including GDPR and French data protection laws. For more context on web scraping legality, see [Apify's guide on web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

Explore more ParseBird data extraction tools:

- [Fotocasa Scraper](https://apify.com/parsebird/fotocasa-scraper) — Extract Spanish real estate listings from Fotocasa.es
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — Send custom HTTP requests with full control over headers, method, and body
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate records from any Apify dataset
- [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Clean, transform, and validate dataset records

### FAQ

**Can I filter companies by department, city, or NAF code?**
Yes. Build your search on [pappers.fr/recherche](https://www.pappers.fr/recherche) with any combination of filters, copy the URL, and paste it into the Search URLs field. All parameters are preserved automatically.

**Does the Actor return financial data?**
The Actor returns data from the Pappers.fr search results, which includes basic company information, directors, and establishments. Detailed financial data (revenue, profit, balance sheets) is available on individual company pages and is not included in search results.

**How many results can I get?**
Set maxResults to 0 for unlimited results. The Actor uses cursor-based pagination to fetch all matching companies without any hard limit.

**What is the difference between standard and strict precision?**
Standard mode returns broader matches including partial name matches. Strict mode only returns exact matches for your search terms.

**Can I schedule recurring runs?**
Yes. Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run the Actor daily, weekly, or at any custom interval. Combine with [integrations](https://apify.com/integrations) to push results to Google Sheets, Slack, webhooks, or your database.

**Does it work for auto-entrepreneurs and individual businesses?**
Yes. Pappers.fr indexes all French registered entities including individual entrepreneurs (EI, auto-entrepreneurs), identified by name and SIREN number.

**What is a SIREN number?**
SIREN is a 9-digit unique identifier assigned by INSEE to every French registered business. It is the primary key for French company data and is included in every result.

**Can I integrate the results with my CRM or database?**
Yes. Use the [Apify API](https://docs.apify.com/api/v2) to trigger runs programmatically and retrieve results in JSON format. Apify also offers direct integrations with [Zapier](https://apify.com/integrations/zapier), [Make](https://apify.com/integrations/make), [Google Sheets](https://apify.com/integrations/google-sheets), and more.

# Actor input Schema

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

Paste one or more URLs from pappers.fr/recherche. All filter parameters (departement, commune, code\_naf, etat, etc.) are preserved and passed to the API automatically.

## `queries` (type: `array`):

Enter keywords to search across company names, directors, and publications. Each query runs independently and results are merged.

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

Maximum number of company results to collect per query or URL. Set to 0 for unlimited results. Pagination is automatic.

## `precision` (type: `string`):

Standard returns broader matches. Strict returns only exact matches. Applies to keyword queries only — URLs use their own parameters.

## `bases` (type: `string`):

Comma-separated list of databases to search: entreprises, dirigeants, publications. Applies to keyword queries only.

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

Proxy settings for the scraper. Residential proxies with France country code are recommended for best reliability.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.pappers.fr/recherche?q=AMD+RENTAL"
  ],
  "queries": [
    "boulangerie paris"
  ],
  "maxResults": 10,
  "precision": "standard",
  "bases": "entreprises",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchUrls": [
        "https://www.pappers.fr/recherche?q=AMD+RENTAL"
    ],
    "queries": [
        "boulangerie paris"
    ],
    "maxResults": 10,
    "precision": "standard",
    "bases": "entreprises",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/pappers-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 = {
    "searchUrls": ["https://www.pappers.fr/recherche?q=AMD+RENTAL"],
    "queries": ["boulangerie paris"],
    "maxResults": 10,
    "precision": "standard",
    "bases": "entreprises",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/pappers-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrls": [
    "https://www.pappers.fr/recherche?q=AMD+RENTAL"
  ],
  "queries": [
    "boulangerie paris"
  ],
  "maxResults": 10,
  "precision": "standard",
  "bases": "entreprises",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call parsebird/pappers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parsebird/pappers-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pappers.fr Company Scraper",
        "description": "Scrape French company data from Pappers.fr — SIREN, legal form, address, directors, financials, and establishments. Search by keyword or paste pappers.fr/recherche URLs with filters. Export as JSON, CSV, Excel.",
        "version": "1.1",
        "x-build-id": "uKeCUWLTutzEQcEWx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~pappers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-pappers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parsebird~pappers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-pappers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parsebird~pappers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-pappers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste one or more URLs from pappers.fr/recherche. All filter parameters (departement, commune, code_naf, etat, etc.) are preserved and passed to the API automatically.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Enter keywords to search across company names, directors, and publications. Each query runs independently and results are merged.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results Per Query/URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of company results to collect per query or URL. Set to 0 for unlimited results. Pagination is automatic.",
                        "default": 50
                    },
                    "precision": {
                        "title": "Search Precision",
                        "enum": [
                            "standard",
                            "strict"
                        ],
                        "type": "string",
                        "description": "Standard returns broader matches. Strict returns only exact matches. Applies to keyword queries only — URLs use their own parameters.",
                        "default": "standard"
                    },
                    "bases": {
                        "title": "Search Bases",
                        "type": "string",
                        "description": "Comma-separated list of databases to search: entreprises, dirigeants, publications. Applies to keyword queries only.",
                        "default": "entreprises,dirigeants,publications"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Residential proxies with France country code are recommended for best reliability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "FR"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
