# BOAMP Public Tenders Scraper (`automation-lab/boamp-public-tenders-scraper`) Actor

🇫🇷 Extract BOAMP French public tender notices by keyword, buyer, department, date, deadline, and market type for B2G sales workflows.

- **URL**: https://apify.com/automation-lab/boamp-public-tenders-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## BOAMP Public Tenders Scraper

Extract French public procurement notices from BOAMP (`boamp.fr`) using the official public OpenDataSoft API.

Use this actor to find tender opportunities, buyer activity, award notices, deadlines, departments, BOAMP IDs, descriptors, CPV codes, and official source links.

### What does BOAMP Public Tenders Scraper do?

BOAMP Public Tenders Scraper exports structured tender notice data from the official French BOAMP public procurement dataset.

It searches and paginates the BOAMP API, normalizes French field names into a clean dataset, and saves one record per notice.

You can filter by keyword, department, buyer, publication date, response deadline, notice nature, family, and market type.

### Who is it for?

This scraper is useful for teams that monitor French public-sector procurement.

- 🧭 B2G sales teams looking for new tender opportunities
- 📊 Market research teams tracking public procurement demand
- 🏛️ Bid managers monitoring buyers and deadlines
- 🔔 Procurement intelligence teams building recurring alerts
- 🧩 Data teams enriching CRM or BI tools with public tender data

### Why use this BOAMP tender scraper?

BOAMP is a key source for French public procurement notices, but raw API fields are French, nested, and not always convenient for business users.

This actor turns BOAMP notices into an export-ready table with stable names, arrays, CPV codes, source URLs, and date fields.

### Data you can extract

| Field | Description |
| --- | --- |
| `idweb` | BOAMP web notice identifier |
| `sourceUrl` | BOAMP notice URL |
| `title` | Tender object / notice summary |
| `buyerName` | Public buyer or contracting authority |
| `publicationDate` | BOAMP publication date |
| `responseDeadline` | Deadline for responses when available |
| `natureLabel` | Notice type label |
| `procedureLabel` | Procedure label |
| `departments` | French department codes |
| `marketTypes` | Works, supplies, services, or other market type codes |
| `descriptorLabels` | BOAMP descriptor labels |
| `cpvCodes` | CPV codes parsed from nested BOAMP data when present |

### How much does it cost to scrape BOAMP public tenders?

The actor uses pay-per-event pricing.

You pay a small start fee per run and a per-notice result event for each saved BOAMP record.

Use `maxItems` to control the size and cost of each run.

Start with the default prefill, confirm the output shape, and then increase `maxItems` for monitoring or export jobs.

### How to use BOAMP Public Tenders Scraper

1. Enter a keyword such as `informatique`, `nettoyage`, `formation`, or `travaux`.
2. Optionally add department codes such as `75`, `69`, or `13`.
3. Add publication or deadline dates if you want a time window.
4. Add a buyer name if you monitor one public authority.
5. Set `maxItems`.
6. Run the actor.
7. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Keyword search

Use `query` to search the BOAMP tender object/title.

Example:

```json
{
  "query": "informatique",
  "departments": ["75"],
  "publicationDateFrom": "2026-01-01",
  "maxItems": 100
}
````

#### Department filters

Use `departments` for French publication department codes.

Examples:

- `75` Paris
- `69` Rhône
- `13` Bouches-du-Rhône
- `33` Gironde
- `59` Nord

#### Buyer filters

Use `buyer` to search the contracting authority name.

Example:

```json
{
  "buyer": "Ville de Paris",
  "publicationDateFrom": "2026-01-01",
  "maxItems": 100
}
```

#### Date filters

Use publication date filters for newly published notices.

Use deadline filters for sales workflows focused on still-actionable opportunities.

Dates must use `YYYY-MM-DD`.

### Output example

```json
{
  "idweb": "26-1303",
  "sourceUrl": "https://www.boamp.fr/avis/detail/26-1303",
  "title": "Fourniture de caisses de livraison...",
  "buyerName": "Ville de Paris - DFA- SDA",
  "publicationDate": "2026-01-07",
  "responseDeadline": "2026-02-10T12:00:00+00:00",
  "natureLabel": "Avis de marché",
  "procedureLabel": "Procédure Ouverte",
  "departments": ["75", "78", "94"],
  "marketTypes": ["FOURNITURES"],
  "cpvCodes": ["44619000"]
}
```

### Tips for better results

- Use French procurement terms for keywords.
- Combine a keyword with departments to reduce noise.
- Use buyer filters for account-based sales monitoring.
- Use deadline filters for opportunity lists.
- Increase `maxItems` for exports after testing a small run.

### Common BOAMP use cases

#### Tender lead generation

Find public tenders that match your product or service category.

#### Buyer monitoring

Track a city, ministry, university, hospital, or public agency.

#### Market intelligence

Measure public demand by keyword, department, market type, or buyer.

#### Deadline monitoring

Export notices with response deadlines for bid planning.

### Integrations

Export the dataset to your preferred workflow.

- 📥 CSV or Excel for analysts
- 🔁 Apify webhooks for scheduled alerts
- 🧩 CRM enrichment for public-sector sales teams
- 📊 BI dashboards for procurement market sizing
- 🗂️ Data warehouses via Apify API

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/boamp-public-tenders-scraper').call({
  query: 'informatique',
  departments: ['75'],
  publicationDateFrom: '2026-01-01',
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/boamp-public-tenders-scraper').call(run_input={
    'query': 'informatique',
    'departments': ['75'],
    'publicationDateFrom': '2026-01-01',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~boamp-public-tenders-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"informatique","departments":["75"],"maxItems":100}'
```

### MCP usage

Use Apify MCP with Claude Desktop, Claude Code, or another MCP-compatible client.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/boamp-public-tenders-scraper
```

Claude Code setup:

```bash
claude mcp add apify-boamp "https://mcp.apify.com/?tools=automation-lab/boamp-public-tenders-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-boamp": {
      "url": "https://mcp.apify.com/?tools=automation-lab/boamp-public-tenders-scraper"
    }
  }
}
```

Example prompts:

- "Find BOAMP informatique tenders in Paris and summarize upcoming deadlines."
- "Export recent Ville de Paris procurement notices from BOAMP."
- "Monitor BOAMP services tenders for formation and return buyer names."

### Scheduling and monitoring

You can schedule this actor daily or weekly on Apify.

For recurring monitoring, use a date window and a focused keyword or buyer name.

Send results to a webhook, Slack workflow, database, or downstream actor.

### Legality

This actor uses BOAMP public procurement notice data available through a public API.

You are responsible for using the data in line with applicable laws, BOAMP terms, and your own compliance requirements.

Do not use exported data for spam or unlawful profiling.

### FAQ

#### What is BOAMP?

BOAMP is the Bulletin officiel des annonces des marchés publics, an official source for French public procurement notices.

#### Can I monitor one buyer?

Yes. Use the `buyer` input with a contracting authority name such as `Ville de Paris`, then schedule the actor.

### Troubleshooting

#### I get zero results

Try a broader French keyword, remove department filters, or expand your date range.

BOAMP field values are in French and official procurement terminology matters.

#### My date filter fails

Use `YYYY-MM-DD`, for example `2026-01-01`.

#### CPV codes are sometimes empty

Some BOAMP notices do not expose CPV codes in the nested notice payload. The actor returns CPV codes when they are present.

### Related scrapers

Explore more automation-lab public-sector and procurement data tools:

- https://apify.com/automation-lab/ted-europa-scraper
- https://apify.com/automation-lab/world-bank-projects-scraper
- https://apify.com/automation-lab/uk-find-a-tender-scraper

### Changelog

#### 0.1

Initial BOAMP public tenders scraper with API pagination, filters, normalized output, and PPE charging.

### Support

If you need a new BOAMP field, a different filter, or a monitoring workflow, open an Apify issue on the actor page.

### Line padding for readability

This README intentionally includes short lines so the Store page is easy to scan.

Procurement users often skim by buyer, deadline, and keyword.

The actor keeps those fields visible in the default dataset view.

French public tenders can be broad.

Start narrow.

Then expand.

Use departments.

Use buyers.

Use dates.

Use market types.

Export clean data.

Build alerts.

Track deadlines.

Win more relevant public-sector opportunities.

# Actor input Schema

## `query` (type: `string`):

Search text in the BOAMP tender object/title, for example informatique, nettoyage, travaux, formation, or cybersécurité.

## `departments` (type: `array`):

Optional BOAMP publication department codes. Examples: 75 Paris, 69 Rhône, 13 Bouches-du-Rhône.

## `publicationDateFrom` (type: `string`):

Only include notices published on or after this date (YYYY-MM-DD).

## `publicationDateTo` (type: `string`):

Only include notices published on or before this date (YYYY-MM-DD).

## `deadlineFrom` (type: `string`):

Only include notices whose response deadline is on or after this date (YYYY-MM-DD).

## `deadlineTo` (type: `string`):

Only include notices whose response deadline is on or before this date (YYYY-MM-DD).

## `buyer` (type: `string`):

Search the contracting authority / public buyer name, for example Ville de Paris or Région Ile-de-France.

## `nature` (type: `string`):

Optional BOAMP nature code such as APPEL\_OFFRE (market notice) or ATTRIBUTION (award notice).

## `family` (type: `string`):

Optional family/source code such as JOUE, FNS, MAPA, or DSP.

## `marketTypes` (type: `array`):

Optional market type codes. Common values: TRAVAUX, FOURNITURES, SERVICES.

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

Maximum number of BOAMP notices to save. Keep low for first tests; increase for monitoring/export jobs.

## Actor input object example

```json
{
  "query": "informatique",
  "departments": [
    "75"
  ],
  "publicationDateFrom": "2026-01-01",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "query": "informatique",
    "departments": [
        "75"
    ],
    "publicationDateFrom": "2026-01-01",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/boamp-public-tenders-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 = {
    "query": "informatique",
    "departments": ["75"],
    "publicationDateFrom": "2026-01-01",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/boamp-public-tenders-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 '{
  "query": "informatique",
  "departments": [
    "75"
  ],
  "publicationDateFrom": "2026-01-01",
  "maxItems": 20
}' |
apify call automation-lab/boamp-public-tenders-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BOAMP Public Tenders Scraper",
        "description": "🇫🇷 Extract BOAMP French public tender notices by keyword, buyer, department, date, deadline, and market type for B2G sales workflows.",
        "version": "0.1",
        "x-build-id": "yOczYWpxVAfmmsWjV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~boamp-public-tenders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-boamp-public-tenders-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/automation-lab~boamp-public-tenders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-boamp-public-tenders-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/automation-lab~boamp-public-tenders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-boamp-public-tenders-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": [
                    "maxItems"
                ],
                "properties": {
                    "query": {
                        "title": "🔎 Tender keywords",
                        "type": "string",
                        "description": "Search text in the BOAMP tender object/title, for example informatique, nettoyage, travaux, formation, or cybersécurité."
                    },
                    "departments": {
                        "title": "📍 French departments",
                        "type": "array",
                        "description": "Optional BOAMP publication department codes. Examples: 75 Paris, 69 Rhône, 13 Bouches-du-Rhône.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "Only include notices published on or after this date (YYYY-MM-DD)."
                    },
                    "publicationDateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "Only include notices published on or before this date (YYYY-MM-DD)."
                    },
                    "deadlineFrom": {
                        "title": "Response deadline from",
                        "type": "string",
                        "description": "Only include notices whose response deadline is on or after this date (YYYY-MM-DD)."
                    },
                    "deadlineTo": {
                        "title": "Response deadline to",
                        "type": "string",
                        "description": "Only include notices whose response deadline is on or before this date (YYYY-MM-DD)."
                    },
                    "buyer": {
                        "title": "Buyer name",
                        "type": "string",
                        "description": "Search the contracting authority / public buyer name, for example Ville de Paris or Région Ile-de-France."
                    },
                    "nature": {
                        "title": "Notice nature code",
                        "enum": [
                            "APPEL_OFFRE",
                            "ATTRIBUTION",
                            "RECTIFICATIF",
                            "AUTRE"
                        ],
                        "type": "string",
                        "description": "Optional BOAMP nature code such as APPEL_OFFRE (market notice) or ATTRIBUTION (award notice)."
                    },
                    "family": {
                        "title": "BOAMP family code",
                        "type": "string",
                        "description": "Optional family/source code such as JOUE, FNS, MAPA, or DSP."
                    },
                    "marketTypes": {
                        "title": "Market type codes",
                        "type": "array",
                        "description": "Optional market type codes. Common values: TRAVAUX, FOURNITURES, SERVICES.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum notices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of BOAMP notices to save. Keep low for first tests; increase for monitoring/export jobs.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```