# ORIAS France Scraper (`solidcode/orias-fr-scraper`) Actor

\[💰 $5 / 1K] Extract insurance, banking, finance & crowdfunding intermediaries from the official French ORIAS register — name, SIREN, address, contacts, activity categories & status. Search by name, registration number, or category.

- **URL**: https://apify.com/solidcode/orias-fr-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## ORIAS France Scraper

Extract registered insurance, banking, finance, and crowdfunding intermediaries from the official French ORIAS register — registration number, SIREN, legal identity, activity categories, registration status, structured address, contacts, and linked mandating insurers, one clean row per intermediary. Built for compliance and KYC/AML teams, B2B lead-gen specialists, and brokers verifying competitor registration who need authoritative ORIAS data without copying it profile-by-profile from the public portal.

### Why This Scraper?

- **15 verified activity categories across four families** — insurance (COA, MIA, MA, AGA, MAL, EII), banking (COBSP, MOBSP, MIOBSP, MOBSPL, ICIE), finance (CIF, ALPSI) and crowdfunding (CIP, IFP), each selectable by a plain-English title instead of a bare code.
- **Official ORIAS registration number plus SIREN on every record** — the two identifiers French compliance workflows actually key on, both returned and cross-resolved (enter an ORIAS number, get the underlying SIREN).
- **Linked mandating insurers (mandants) per record** — every associated entity comes back as a structured row with its own `siren`, `name`, address, and ORIAS profile URL, so you can map a broker's full insurer network.
- **Registration status and per-category history** — `registrationStatus` (Inscrit / Radié / Supprimé) at the record level, plus each activity's own status with `registeredAt` and `withdrawnAt` dates.
- **Structured French address and E.164 phone** — `address`, `zipcode`, `city`, `country` split from the raw line, plus both the raw `phone` and a normalized `phoneE164` for international dialing and CRM import.
- **Complete national register coverage** — every one of the 40,000+ French insurance, banking, finance, and crowdfunding intermediaries on the official ORIAS register, not a partial export or a single category.
- **Three ways to target records in one run** — by name or keyword, by ORIAS / SIREN number, or by entire activity category — mix all three plus pasted profile URLs in a single input.
- **Legal identity block on every profile** — `legalForm`, `legalStatus`, `nafCode` (NAF/APE), `rcs`, and commercial name, ready for due-diligence and entity-resolution pipelines.

### Use Cases

**Compliance & KYC/AML**
- Verify an intermediary holds a current ORIAS registration before onboarding
- Confirm the regulated activities (IAS / IOBSP / CIF / IFP) a counterparty is authorized for
- Flag radié (struck-off) or supprimé registrations during periodic reviews
- Resolve an ORIAS number to its SIREN for cross-referencing in your KYC system

**Lead Generation**
- Build prospect lists of brokers by activity category with email, phone, and website
- Segment the insurance broker (COA) population by city or postal code
- Export ready-to-import contact rows with E.164 phone numbers for outbound campaigns
- Target newly registered intermediaries in a specific finance or crowdfunding segment

**Competitive Intelligence**
- Track a competitor's registration status and which categories they hold
- Map which insurers a rival brokerage acts as a mandant for
- Monitor entrants and exits across an activity family over time
- Benchmark commercial-name footprints across a region

**Due Diligence & Market Research**
- Enumerate an entire activity segment to size a market (e.g. all CIF advisors)
- Enrich an internal partner database with SIREN, NAF code, and legal form
- Validate counterparties in M&A and partnership screening
- Analyze the geographic distribution of intermediaries across France

### Getting Started

#### Browse a Single Category

Pull every intermediary in one activity category — here, financial investment advisors (CIF):

```json
{
    "categories": ["CIF"],
    "maxResults": 200
}
````

#### Search by Name with a Cap

Look up a company or trade name and limit the run while you test:

```json
{
    "searchTerms": ["April", "Verlingue"],
    "maxResults": 50
}
```

#### Multi-Category Plus Direct Lookups

Combine a full insurance-broker enumeration with precise number lookups in one run:

```json
{
    "categories": ["COA", "MOBSP"],
    "registrationNumbers": ["07009384", "529742848"],
    "searchTerms": ["Boutard"],
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

You can use any combination of these — leave the rest empty. Every field is optional.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["April"]` | Names or keywords to look up — a company name, a person's name, or a trade name. Each term runs as its own search. |
| `registrationNumbers` | string\[] | `[]` | ORIAS registration numbers and/or SIREN numbers. Short SIRENs are padded automatically; ORIAS numbers resolve to the underlying profile. |
| `categories` | select\[] | `[]` | One or more regulated activities to enumerate every intermediary registered under. See the category list below. |
| `startUrls` | string\[] | `[]` | Paste ORIAS profile or search-result URLs (e.g. `https://orias.fr/home/showIntermediaire/000032630`) directly. |

#### Activity Categories

Select any combination from the four regulated families:

| Family | Categories |
|--------|------------|
| Insurance (IAS) | Insurance broker (COA), Insurance intermediary's agent (MIA), Insurance agent (MA), General insurance agent (AGA), Tied insurance agent (MAL), European insurance intermediary (EII) |
| Banking (IOBSP) | Banking broker (COBSP), Banking agent (MOBSP), Banking intermediary's agent (MIOBSP), Tied banking agent (MOBSPL), European credit intermediary (ICIE) |
| Finance | Financial investment advisor (CIF), Tied investment services agent (ALPSI) |
| Crowdfunding | Crowdfunding advisor (CIP), Crowdfunding intermediary (IFP) |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of records to collect across all searches, numbers, categories, and URLs. Set to `0` for no cap (a safety ceiling of 50,000 records still applies). The final page is kept whole even if it slightly overshoots. |

### Output

Each result is one flat intermediary record. Here's a representative item:

```json
{
    "oriasNumber": "07009384",
    "name": "APRIL",
    "commercialName": "APRIL ASSURANCES",
    "siren": "377994553",
    "legalForm": "Société anonyme",
    "legalStatus": "Personne morale",
    "nafCode": "6622Z",
    "rcs": "377 994 553 RCS LYON",
    "registrationStatus": "Inscrit",
    "categories": [
        {
            "code": "COA",
            "label": "Courtier en assurance",
            "role": "COA",
            "status": "Inscrit",
            "registeredAt": "14/04/2007",
            "withdrawnAt": null
        }
    ],
    "email": "contact@april.com",
    "phone": "04 73 23 45 67",
    "phoneE164": "+33473234567",
    "website": "https://www.april.com",
    "address": "114 boulevard Marius Vivier Merle",
    "zipcode": "69003",
    "city": "Lyon",
    "country": "France",
    "addressFull": "114 boulevard Marius Vivier Merle 69003 Lyon France",
    "associations": [
        {
            "siren": "562073255",
            "name": "AXA FRANCE IARD",
            "address": "313 Terrasses de l'Arche",
            "city": "Nanterre",
            "zipcode": "92727",
            "country": "France",
            "url": "https://www.orias.fr/home/showIntermediaire/562073255"
        }
    ],
    "url": "https://www.orias.fr/home/showIntermediaire/377994553"
}
```

#### Identity & Registration

| Field | Type | Description |
|-------|------|-------------|
| `oriasNumber` | string | Official ORIAS registration number (numéro d'immatriculation) |
| `name` | string | Registered legal name |
| `commercialName` | string | Trade name / sign / commercial name, if different |
| `siren` | string | 9-digit SIREN company identifier (digits only) |
| `legalForm` | string | Legal form (e.g. SAS, SARL, Société anonyme) |
| `legalStatus` | string | Legal status (e.g. personne morale / personne physique) |
| `nafCode` | string | NAF/APE business activity code |
| `rcs` | string | RCS commercial registry reference |
| `registrationStatus` | string | Record status: Inscrit, Radié, or Supprimé |
| `url` | string | Direct ORIAS profile URL |

#### Activity Categories (`categories[]`)

| Field | Type | Description |
|-------|------|-------------|
| `code` | string | Activity code (COA, CIF, COBSP, IFP, etc.) |
| `label` | string | Full French label for the activity |
| `role` | string | Role identifier for the activity |
| `status` | string | Status of this specific activity |
| `registeredAt` | string | Date this activity was registered (DD/MM/YYYY) |
| `withdrawnAt` | string | Date this activity was withdrawn, if any |

#### Contact & Address

| Field | Type | Description |
|-------|------|-------------|
| `email` | string | Contact email (decoded) |
| `phone` | string | Contact phone as published |
| `phoneE164` | string | Phone normalized to E.164 (e.g. +33473234567) |
| `website` | string | Website URL |
| `address` | string | Street address |
| `zipcode` | string | Postal code |
| `city` | string | City |
| `country` | string | Country (defaults to France) |
| `addressFull` | string | Complete single-line address |

#### Linked Entities (`associations[]`)

| Field | Type | Description |
|-------|------|-------------|
| `siren` | string | SIREN of the linked / mandating entity |
| `name` | string | Name of the linked entity (mandant) |
| `address` | string | Street address of the linked entity |
| `city` | string | City of the linked entity |
| `zipcode` | string | Postal code of the linked entity |
| `country` | string | Country of the linked entity |
| `url` | string | ORIAS profile URL of the linked entity |

### Tips for Best Results

- **Use categories to enumerate a whole segment, numbers for precise KYC.** Activity categories sweep an entire regulated population; registration / SIREN numbers pin down a single counterparty for verification.
- **Start with a small `maxResults`.** Set it to 50–200 on a first run to confirm the data fits your workflow, then scale up. Large categories like insurance broker (COA) hold tens of thousands of records.
- **Enter an ORIAS number directly — no SIREN required.** ORIAS registration numbers are auto-resolved to the underlying profile, so you can paste whatever identifier you already have.
- **Combine inputs in one run.** Mix search terms, registration numbers, categories, and pasted URLs together; results are deduplicated across all of them.
- **Read `registrationStatus` before trusting a record.** A Radié or Supprimé status means the intermediary is no longer actively authorized — essential for compliance reviews.
- **Use `phoneE164` for CRM and dialer import.** It is already normalized for international dialing, while `phone` preserves the original published format.
- **Map insurer networks via `associations[]`.** Each mandant row links to its own ORIAS profile, so you can follow the chain from a broker to every insurer it represents.

### Pricing

**From $5.00 per 1,000 results** — flat per-record pricing for the full ORIAS register, billed only on what you collect. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is any intermediary record in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

ORIAS is an official public register, published so that consumers and professionals can verify the registration of insurance, banking, and finance intermediaries. This actor collects that public data for legitimate compliance, verification, due-diligence, and business purposes. You are responsible for complying with applicable laws — including the GDPR when records contain personal data — and with ORIAS's terms of use. Do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

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

Names or keywords to look up in the ORIAS register — a company name, a person's name, or a trade name (e.g. "Boutard", "April", "Verlingue"). Each term runs as its own search. Leave empty if you only want to use registration numbers, categories, or URLs below.

## `registrationNumbers` (type: `array`):

ORIAS registration numbers (numéro d'immatriculation) and/or SIREN numbers. Short SIRENs (1–9 digits) are accepted and padded automatically. Each number is resolved to one intermediary profile.

## `categories` (type: `array`):

Browse every intermediary registered under these regulated activities. Leave empty to skip category browsing. Note: large categories (e.g. Insurance Broker) contain tens of thousands of records — use the Max Results limit below.

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

Paste ORIAS profile URLs (e.g. https://orias.fr/home/showIntermediaire/000032630) or search-result URLs directly. Useful when you already have links you want to extract.

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

Maximum number of intermediary records to collect across all searches, numbers, categories and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (a safety ceiling of 50,000 records still applies to prevent runaway crawls). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchTerms": [
    "April"
  ],
  "registrationNumbers": [],
  "categories": [],
  "startUrls": [],
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped intermediaries with the most useful columns at a glance.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "April"
    ],
    "registrationNumbers": [],
    "categories": [],
    "startUrls": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/orias-fr-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["April"],
    "registrationNumbers": [],
    "categories": [],
    "startUrls": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/orias-fr-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 '{
  "searchTerms": [
    "April"
  ],
  "registrationNumbers": [],
  "categories": [],
  "startUrls": [],
  "maxResults": 100
}' |
apify call solidcode/orias-fr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ORIAS France Scraper",
        "description": "[💰 $5 / 1K] Extract insurance, banking, finance & crowdfunding intermediaries from the official French ORIAS register — name, SIREN, address, contacts, activity categories & status. Search by name, registration number, or category.",
        "version": "1.0",
        "x-build-id": "o7GqIhO6m7PuBZZDE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~orias-fr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-orias-fr-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/solidcode~orias-fr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-orias-fr-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/solidcode~orias-fr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-orias-fr-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": {
                    "searchTerms": {
                        "title": "Search Names / Keywords",
                        "type": "array",
                        "description": "Names or keywords to look up in the ORIAS register — a company name, a person's name, or a trade name (e.g. \"Boutard\", \"April\", \"Verlingue\"). Each term runs as its own search. Leave empty if you only want to use registration numbers, categories, or URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "registrationNumbers": {
                        "title": "Registration / SIREN Numbers",
                        "type": "array",
                        "description": "ORIAS registration numbers (numéro d'immatriculation) and/or SIREN numbers. Short SIRENs (1–9 digits) are accepted and padded automatically. Each number is resolved to one intermediary profile.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Activity Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Browse every intermediary registered under these regulated activities. Leave empty to skip category browsing. Note: large categories (e.g. Insurance Broker) contain tens of thousands of records — use the Max Results limit below.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "COA",
                                "MIA",
                                "MA",
                                "AGA",
                                "MAL",
                                "EII",
                                "COBSP",
                                "MOBSP",
                                "MIOBSP",
                                "MOBSPL",
                                "ICIE",
                                "CIF",
                                "CIP",
                                "ALPSI",
                                "IFP"
                            ],
                            "enumTitles": [
                                "Insurance broker — Courtier en assurance (COA)",
                                "Insurance intermediary's agent — Mandataire d'intermédiaire en assurance (MIA)",
                                "Insurance agent — Mandataire d'assurance (MA)",
                                "General insurance agent — Agent général d'assurance (AGA)",
                                "Tied insurance agent — Mandataire d'assurance lié (MAL)",
                                "European insurance intermediary — Intermédiaire d'assurance européen (EII)",
                                "Banking broker — Courtier en opérations de banque (COBSP)",
                                "Banking agent — Mandataire en opérations de banque (MOBSP)",
                                "Banking intermediary's agent — Mandataire d'intermédiaire bancaire (MIOBSP)",
                                "Tied banking agent — Mandataire lié en opérations de banque (MOBSPL)",
                                "European credit intermediary — Intermédiaire de crédit européen (ICIE)",
                                "Financial investment advisor — Conseiller en investissements financiers (CIF)",
                                "Crowdfunding advisor — Conseiller en investissements participatifs (CIP)",
                                "Tied investment services agent — Agent lié de prestataire de services d'investissement (ALPSI)",
                                "Crowdfunding intermediary — Intermédiaire en financement participatif (IFP)"
                            ]
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "ORIAS URLs",
                        "type": "array",
                        "description": "Paste ORIAS profile URLs (e.g. https://orias.fr/home/showIntermediaire/000032630) or search-result URLs directly. Useful when you already have links you want to extract.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of intermediary records to collect across all searches, numbers, categories and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (a safety ceiling of 50,000 records still applies to prevent runaway crawls). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
