# France B2B Leads Scraper (`reviewly/pagejaunes-leads-scraper`) Actor

Extrayez des données d'entreprises françaises depuis PagesJaunes.fr incluant téléphones, emails, sites web, avis clients et coordonnées GPS. Parfait pour la génération de leads B2B et la prospection commerciale en France.

- **URL**: https://apify.com/reviewly/pagejaunes-leads-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Lead generation, AI, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 record scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## France B2B Leads Scraper - Leads Français

Extrayez des données complètes d'entreprises françaises depuis PagesJaunes.fr incluant les coordonnées, avis clients, coordonnées GPS et détails complets. Parfait pour la génération de leads B2B, la prospection commerciale et l'étude de marché en France.

### Qu'est-ce que France B2B Leads Scraper ?

France B2B Leads Scraper est un outil puissant qui extrait les données d'entreprises publiquement disponibles sur PagesJaunes.fr, le premier annuaire professionnel français avec des millions de listings. Entrez simplement une catégorie et une localisation pour obtenir des données structurées avec numéros de téléphone, emails, sites web, notes clients et coordonnées GPS précises. Idéal pour **les équipes commerciales, marketeurs, développeurs commerciaux et entrepreneurs** ciblant le marché français.

**Avantages clés d'utiliser cet Actor sur Apify:**
- ⏰ **Planification** - Extraction automatique quotidienne, hebdomadaire ou mensuelle
- 🔄 **Accès API** - Intégrez les données dans votre CRM ou système
- 🌐 **Proxies résidentiels français** - Scraping fiable sans détection
- 📊 **Formats d'export multiples** - JSON, CSV, Excel, XML
- 🔗 **Intégrations** - Connexion avec Zapier, Make, webhooks
- 📈 **Surveillance** - Suivi des performances et alertes
- 🗺️ **Coordonnées GPS** - Latitude/longitude pour chaque entreprise
- ⭐ **Avis clients** - Notes et nombre d'avis par source

### Que peut faire France B2B Leads Scraper ?

Cet Actor offre des fonctionnalités puissantes pour extraire des données d'entreprises françaises :

✅ **Recherche par mots-clés** - Trouvez n'importe quelle catégorie (restaurants, plombiers, avocats, dentistes)
✅ **Ciblage géographique** - Recherchez dans des villes ou régions spécifiques
✅ **Données de contact complètes** - Numéros de téléphone, emails, sites web
✅ **Coordonnées GPS** - Latitude/longitude précises pour cartographie
✅ **Avis clients** - Notes, nombre d'avis et avis par source
✅ **Détails d'entreprise** - Adresses complètes, codes postaux, catégories
✅ **Extraction en volume** - Jusqu'à 10 000 entreprises par exécution
✅ **Couverture nationale** - Accès à toutes les villes et départements français
✅ **Données fraîches** - Extraction en temps réel depuis PagesJaunes.fr
✅ **Listings vérifiés** - Données officielles de l'annuaire français

### Quelles données France B2B Leads Scraper peut-il extraire ?

| Champ | Description | Exemple |
|-------|-------------|---------|
| **ID** | Identifiant unique | PJ-123456 |
| **Nom** | Raison sociale | "Restaurant Le Soleil" |
| **Adresse** | Adresse postale | "42 Avenue des Champs" |
| **Ville** | Commune | "Lyon" |
| **Code Postal** | Code postal français | "69002" |
| **Téléphones** | Numéro(s) de téléphone | ["+33 4 XX XX XX XX"] |
| **Emails** | Adresse(s) email | ["contact@exemple.fr"] |
| **Sites Web** | URL(s) du site | ["https://exemple.fr"] |
| **Catégorie** | Catégorie d'activité | "Restaurant français" |
| **Latitude GPS** | Coordonnée latitude | "45.7640" |
| **Longitude GPS** | Coordonnée longitude | "4.8357" |
| **URL PagesJaunes** | Lien vers l'annonce | Lien direct PagesJaunes |
| **Note** | Note moyenne clients | 4.2/5 |
| **Nombre d'avis** | Total des avis | 87 |
| **Avis par source** | Répartition des avis | {"Google": 54, "PagesJaunes": 33} |

### Comment extraire des leads depuis PagesJaunes

L'utilisation de France B2B Leads Scraper est simple :

1. **Ouvrez France B2B Leads Scraper** dans la console Apify
2. **Entrez le terme de recherche** - Catégorie d'entreprise (ex : "restaurants", "plombiers", "dentistes")
3. **Spécifiez la localisation** - Ville ou région (Paris, Lyon, Marseille, etc.)
4. **Définissez le nombre maximum** - Jusqu'à 10 000 entreprises par exécution (défaut : 100)
5. **Cliquez sur Démarrer** et attendez les résultats
6. **Téléchargez vos données** en JSON, CSV ou Excel

**Termes de recherche courants :**
- Services professionnels : avocat, comptable, notaire, architecte
- Services à domicile : plombier, électricien, serrurier, peintre
- Restauration : restaurant, hôtel, café, boulangerie
- Santé : dentiste, médecin, pharmacie, kinésithérapeute
- Commerce : fleuriste, coiffeur, boucher, garage
- Services entreprises : agence immobilière, cabinet conseil, expert-comptable

**Villes françaises populaires :**
- Paris, Lyon, Marseille, Toulouse, Bordeaux
- Nice, Nantes, Strasbourg, Lille, Rennes

**Intégration avec webhooks**

Automatisez votre génération de leads B2B en configurant des webhooks qui se déclenchent à la fin de l'extraction. Envoyez les données directement vers votre CRM (Salesforce, HubSpot, Pipedrive), plateforme d'email marketing ou outils d'automatisation commerciale.

### Combien coûte l'extraction de données PagesJaunes ?

France B2B Leads Scraper utilise une tarification transparente au résultat :

**💰 $5 pour 1 000 leads**

**Ce que vous obtenez :**
- ✅ Paiement uniquement pour les résultats extraits
- ✅ Pas d'abonnement mensuel ou frais cachés
- ✅ Tous les champs de données inclus (téléphone, email, avis, GPS)
- ✅ Accès API complet et webhooks
- ✅ Planification et surveillance
- ✅ Tous les formats d'export (JSON, CSV, Excel, XML)
- ✅ Proxies résidentiels français inclus
- ✅ Crédit gratuit de 5€ à l'inscription (testez avec 1 000 leads !)

**Exemples de coûts :**
- 100 entreprises = $0,50
- 500 entreprises = $2,50
- 1 000 entreprises = $5
- 5 000 entreprises = $25
- 10 000 entreprises = $50

**Parfait pour :**
- 🎯 Équipes commerciales prospectant en France
- 📊 Analystes de marché étudiant les secteurs français
- 🏢 Entreprises entrant sur le marché français
- 💼 Développeurs d'affaires cherchant des partenaires français
- 📧 Marketeurs lançant des campagnes B2B en France
- 🌍 Entreprises internationales s'implantant en France

Avec le niveau gratuit d'Apify (5€/mois de crédit), vous pouvez extraire jusqu'à 1 000 entreprises françaises gratuitement chaque mois. Aucune carte bancaire requise pour commencer !

### Configuration d'entrée

France B2B Leads Scraper accepte les paramètres d'entrée suivants. Cliquez sur l'onglet **Input** pour la configuration.

**Champs requis :**
- **Terme de recherche** - Catégorie ou mot-clé (ex : "restaurants", "plombiers")
- **Localisation** - Ville ou région en France (ex : "Paris", "Lyon")

**Champs optionnels :**
- **Résultats maximum** - Limiter les résultats (1-10 000 leads, défaut : 100)
- **Configuration proxy** - Proxies résidentiels français (recommandé)

**Exemples de termes de recherche :**
- Alimentation : restaurants, cafés, boulangeries, traiteurs
- Services pros : avocats, notaires, experts-comptables
- Services domicile : plombiers, électriciens, serruriers
- Santé : dentistes, médecins généralistes, pharmacies
- Commerce : fleuristes, coiffeurs, bouchers
- Automobile : garages, concessionnaires, carrosseries

### Données en sortie

France B2B Leads Scraper retourne des données structurées, téléchargeables en JSON, CSV, Excel ou XML.

**Exemple de sortie :**

```json
{
  "id": "PJ-987654",
  "name": "Café de la Place",
  "address": "23 Place Victor Hugo",
  "city": "Toulouse",
  "postalCode": "31000",
  "phones": ["+33 5 XX XX XX XX"],
  "emails": ["info@exemple-cafe.fr"],
  "websites": ["https://www.exemple-cafe.fr"],
  "category": "Café-Restaurant",
  "latitude": "43.6047",
  "longitude": "1.4442",
  "pagesJaunesUrl": "https://www.pagesjaunes.fr/pros/...",
  "rating": 4.3,
  "reviewCount": 92,
  "reviewsBySource": {
    "Google": 61,
    "PagesJaunes": 31
  }
}
````

Le jeu de données est propre, structuré et prêt à être importé dans des CRM, outils commerciaux, applications de cartographie ou plateformes marketing.

### Cas d'usage des données PagesJaunes

#### Ventes & Génération de Leads B2B

- **Listes de prospects français** - Créez des listes ciblées par secteur d'activité
- **Planification territoriale** - Cartographiez les entreprises par région
- **Campagnes de démarchage** - Générez des numéros de téléphone vérifiés
- **Email marketing** - Créez des listes d'emails B2B pour le marché français

#### Étude de Marché

- **Entrée sur le marché** - Analysez les secteurs avant de vous implanter
- **Intelligence concurrentielle** - Identifiez les concurrents en France
- **Cartographie sectorielle** - Comptez les entreprises par catégorie et localisation
- **Recherche de fournisseurs** - Trouvez des prestataires français

#### Développement Commercial

- **Recherche de partenaires** - Trouvez des partenaires potentiels en France
- **Canaux de distribution** - Localisez des distributeurs français
- **Étude de franchise** - Analysez la présence par région
- **Analyse géographique** - Identifiez les marchés sous-desservis

#### Expansion Internationale

- **Dimensionnement du marché** - Comprenez le paysage commercial français
- **Recherche de partenaires locaux** - Trouvez agences, consultants, fournisseurs
- **Chaîne d'approvisionnement** - Sourcez des fabricants français
- **Due diligence** - Recherchez des partenaires commerciaux potentiels

#### Ventes & Marketing

- **Scoring de leads** - Priorisez selon notes et nombre d'avis
- **Planification de tournées** - Planifiez des routes avec coordonnées GPS
- **Campagnes ciblées** - Créez des campagnes par secteur
- **Profiling client** - Analysez les patterns de distribution

### L'extraction de PagesJaunes est-elle légale ?

Oui, l'extraction de données publiques depuis PagesJaunes.fr est légale. La plateforme affiche des informations que les entreprises ont volontairement listées pour être découvertes.

Cependant, vous devez savoir que :

✅ **Ce que nous extrayons** : Uniquement les données publiques (noms, téléphones, adresses, avis)
❌ **Ce que nous n'extrayons pas** : Données privées, informations personnelles non publiques

**Notes importantes de conformité :**

- Les données personnelles sont protégées par le RGPD (UE) et les lois françaises (CNIL)
- Utilisez les données de manière responsable et légitime
- Respectez la réglementation anti-spam française (LCEN)
- N'utilisez pas les données pour du marketing non sollicité sans opt-in
- Fournissez des mécanismes de désinscription
- Conservez des preuves de consentement pour la conformité RGPD
- Consultez un avocat si vous avez des doutes

Notre scraper est conçu pour un usage B2B éthique incluant étude de marché, prospection commerciale et développement d'affaires.

### Conseils pour de meilleurs résultats

**Optimisez vos recherches :**

- 🎯 Utilisez des mots-clés français (les entreprises sont listées en français)
- 📍 Recherchez les grandes villes individuellement
- 🔄 Utilisez des catégories spécifiques plutôt que générales
- 📊 Testez des variations : "restaurant", "restaurant gastronomique", "brasserie"

**Maximisez la qualité des données :**

- ✅ Commencez par les grandes villes : Paris, Lyon, Marseille
- 📱 Vérifiez que les numéros sont au format international (+33)
- 🌐 Contrôlez les URLs de sites web
- ⭐ Utilisez notes et avis pour scorer les leads
- 🗺️ Exploitez les coordonnées GPS pour cartographie

**Idées d'intégration :**

- Import dans Salesforce, HubSpot ou Pipedrive
- Visualisation Google Maps avec coordonnées GPS
- Scoring automatique selon les notes
- Création d'annuaires professionnels
- Tableaux de bord d'analyse de marché
- Intégration avec Mailchimp, Sendinblue

**Besoin d'aide ?**

- 💬 Utilisez l'onglet **Issues** pour signaler bugs
- 📧 Contactez le développeur pour solutions sur-mesure : <me@ahmedhrid.com>
- 🎓 Consultez [Apify Academy](https://docs.apify.com/academy)
- 👥 Rejoignez [Apify Discord](https://discord.com/invite/jyEM2PRvMU)

### Accès API et intégrations

France B2B Leads Scraper offre un accès API complet :

#### API REST

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerm": "restaurants",
    "location": "Paris",
    "maxResults": 500
  }'
```

#### JavaScript/Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const input = {
  searchTerm: "plombiers",
  location: "Lyon",
  maxResults: 1000
};

const run = await client.actor("YOUR_ACTOR_ID").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Filtrer par note
const topNotes = items.filter(lead => lead.rating >= 4.0);
console.log(`Trouvé ${topNotes.length} entreprises bien notées`);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run_input = {
    "searchTerm": "dentistes",
    "location": "Marseille",
    "maxResults": 500
}

run = client.actor("YOUR_ACTOR_ID").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items

## Analyser par nombre d'avis
for item in items:
    if item['reviewCount'] > 50:
        print(f"{item['name']}: {item['rating']}★ ({item['reviewCount']} avis)")
```

# Actor input Schema

## `searchTerm` (type: `string`):

Business category or keyword to search (e.g. 'restaurants', 'plombiers', 'banques').

## `location` (type: `string`):

City or region to search in (e.g. 'Paris', 'Lyon', 'Marseille').

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

Maximum number of leads to scrape.

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

Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.

## Actor input object example

```json
{
  "searchTerm": "restaurants",
  "location": "Paris",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/pagejaunes-leads-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    } }

# Run the Actor and wait for it to finish
run = client.actor("reviewly/pagejaunes-leads-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call reviewly/pagejaunes-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France B2B Leads Scraper",
        "description": "Extrayez des données d'entreprises françaises depuis PagesJaunes.fr incluant téléphones, emails, sites web, avis clients et coordonnées GPS. Parfait pour la génération de leads B2B et la prospection commerciale en France.",
        "version": "0.0",
        "x-build-id": "odzfv4LePQUSAEgww"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~pagejaunes-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-pagejaunes-leads-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/reviewly~pagejaunes-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-pagejaunes-leads-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/reviewly~pagejaunes-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-pagejaunes-leads-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",
                "required": [
                    "searchTerm",
                    "location"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Business category or keyword to search (e.g. 'restaurants', 'plombiers', 'banques').",
                        "default": "restaurants"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search in (e.g. 'Paris', 'Lyon', 'Marseille').",
                        "default": "Paris"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of leads to scrape.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
