# OpenFDA Drug Adverse Events & Recall Scraper (`parseforge/openfda-scraper`) Actor

Scrape FDA drug adverse events, drug labels, and food enforcement recalls from the openFDA public API — no auth required.

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

## Pricing

from $19.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💊 OpenFDA Drug Adverse Events & Recall Scraper

> 🚀 **Export FDA drug adverse events, drug labels, and food recalls in seconds.** No API key, no auth, zero configuration required.

> 🕒 **Last updated:** 2026-05-21 · **📊 11 fields** per drug-event record · **20M+ adverse event reports** · **US FDA coverage, global reporters**

The OpenFDA Scraper collects structured data from the [openFDA public API](https://open.fda.gov/) — the US Food and Drug Administration's official open data platform. No credentials or API keys needed. Data is sourced directly from FDA's FAERS (FDA Adverse Event Reporting System), DailyMed drug labels database, and the FDA enforcement database.

Supports three datasets: drug adverse events (~20 million reports), drug labels (structured prescribing information), and food enforcement recalls (Class I, II, and III). Every record is normalized and ready for download in CSV, JSON, or Excel.

**Coverage:** All adverse event reports submitted to FDA globally. Reporters from 100+ countries. Drug adverse events date back to the 1960s with the most active period from 2004 onwards. Food enforcement recalls cover ongoing and terminated actions.

| Who uses this | Why |
|---|---|
| Pharmacovigilance teams | Monitor adverse drug reaction trends |
| Healthcare researchers | Study drug safety signals across demographics |
| Regulatory affairs analysts | Track FDA enforcement actions and recalls |
| Data scientists | Build ML models on drug-reaction relationships |
| Medical journalists | Investigate drug safety stories with data |
| Public health agencies | Monitor population-level drug event patterns |

### 📋 What the OpenFDA Scraper does

- Fetches drug adverse event reports from FDA FAERS with full patient demographics and reaction terms
- Exports drug label data including active ingredients, warnings, and dosage instructions
- Retrieves food enforcement recalls with classification, firm details, and distribution patterns
- Supports free-text search queries using openFDA's Lucene-based search syntax
- Filters drug events by date range (start/end date)
- Paginates automatically through up to 25,000 results per query window
- Normalizes dates to ISO format, maps coded fields (sex, serious outcome) to human-readable values

> 💡 **Why it matters:** The FDA receives over 1 million adverse event reports per year. This actor gives researchers, analysts, and developers programmatic access to 20+ million historical reports without writing a single line of code.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `maxItems` | integer | Maximum records to collect (free: 10, paid: up to 1,000,000) | 10 |
| `dataType` | select | Dataset to query: `drug_events`, `drug_labels`, or `food_enforcement` | `drug_events` |
| `search` | string | Optional openFDA search expression (Lucene syntax) | _(blank = all)_ |
| `startDate` | string | Filter drug events on/after this date (YYYY-MM-DD) | _(blank)_ |
| `endDate` | string | Filter drug events on/before this date (YYYY-MM-DD) | _(blank)_ |

**Example 1 - Basic drug adverse events:**
```json
{
    "maxItems": 100,
    "dataType": "drug_events"
}
````

**Example 2 - Headache reactions in 2023:**

```json
{
    "maxItems": 500,
    "dataType": "drug_events",
    "search": "patient.reaction.reactionmeddrapt:\"headache\"",
    "startDate": "2023-01-01",
    "endDate": "2023-12-31"
}
```

> ⚠️ **Good to Know:** The openFDA API caps pagination at 25,000 records per query window. To collect more, use the `search` parameter to narrow results to a specific drug, reaction, or date range and run multiple focused queries.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🔑 `safetyReportId` | string | Unique FDA safety report identifier |
| 📅 `receiveDate` | string | ISO date when FDA received the report |
| ⚠️ `serious` | string | Whether the event was serious: `yes` or `no` |
| 💀 `seriousnessDeath` | string | Death outcome: `yes`, `no`, or `null` |
| 🧑 `patientAge` | string | Patient age with unit (e.g. `45 years`) — `null` if not reported |
| 🚻 `patientSex` | string | `male`, `female`, or `unknown` |
| 🔬 `reactions` | array | MedDRA adverse reaction terms |
| 💊 `drugs` | array | Drug names involved (first 5) |
| 🌍 `reportCountry` | string | ISO country code of the primary reporter |
| 🕒 `scrapedAt` | string | ISO timestamp when the record was collected |
| ❌ `error` | string | Error message if record failed — always last |

**Sample records (real output):**

```json
[
  {
    "safetyReportId": "5801206-7",
    "receiveDate": "2008-07-07",
    "serious": "yes",
    "seriousnessDeath": "yes",
    "patientAge": "26 years",
    "patientSex": "male",
    "reactions": ["DRUG ADMINISTRATION ERROR", "OVERDOSE"],
    "drugs": ["DURAGESIC-100"],
    "reportCountry": "CANADA",
    "scrapedAt": "2026-05-21T22:56:46.240Z",
    "error": null
  },
  {
    "safetyReportId": "10003300",
    "receiveDate": "2014-03-06",
    "serious": "yes",
    "seriousnessDeath": null,
    "patientAge": "77 years",
    "patientSex": "female",
    "reactions": ["Vomiting", "Diarrhoea", "Arthralgia", "Headache"],
    "drugs": ["BONIVA"],
    "reportCountry": "US",
    "scrapedAt": "2026-05-21T22:56:46.241Z",
    "error": null
  },
  {
    "safetyReportId": "10003301",
    "receiveDate": "2014-02-28",
    "serious": "yes",
    "seriousnessDeath": null,
    "patientAge": null,
    "patientSex": "female",
    "reactions": ["Dyspepsia", "Renal impairment"],
    "drugs": ["IBUPROFEN"],
    "reportCountry": "US",
    "scrapedAt": "2026-05-21T22:56:46.241Z",
    "error": null
  }
]
```

> **Note on `patientAge`:** This field is `null` when the reporter did not include patient age. This is expected - FDA does not require age in adverse event reports.

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🔓 No auth required | Public openFDA API - zero setup |
| 📊 3 datasets | Drug events, drug labels, food enforcement |
| 🔍 Full search support | Lucene syntax for targeted queries |
| 📅 Date range filtering | Narrow drug events by receive date |
| 🗺 Normalized output | Coded values mapped to readable strings |
| 💊 Multi-drug support | Captures all drugs per adverse event |
| 🌍 Global data | Reports from 100+ countries |
| ⚡ Fast | Plain fetch, no browser overhead |

### 📈 How it compares to alternatives

| | OpenFDA Scraper | Manual API calls | Custom Python script |
|---|---|---|---|
| Setup time | Instant | Hours | Days |
| Pagination handled | Yes | Manual | Manual |
| Field normalization | Yes | No | Custom |
| Apify integrations | Yes | No | No |
| Schedule & monitor | Yes | No | Manual |
| CSV / Excel export | Yes | No | Custom |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Go to the [OpenFDA Scraper](https://apify.com/parseforge/openfda-scraper) page
3. Click **Try for free**
4. Set `dataType` to `drug_events`, `drug_labels`, or `food_enforcement`
5. Optionally add a `search` query and date range
6. Set `maxItems` to the number of records you need
7. Click **Start** and wait for the run to complete
8. Download your dataset in CSV, JSON, Excel, or XML

### 💼 Business use cases

#### Pharmacovigilance and Drug Safety Monitoring

Track adverse events for specific drugs over time. Search for reactions by drug name (`patient.drug.medicinalproduct:"ASPIRIN"`) and monitor reporting trends. Identify drugs with increasing death outcomes or serious reaction rates.

#### Regulatory Compliance and Recall Tracking

Use `food_enforcement` to monitor active FDA recalls. Filter by `classification:"Class I"` for the highest-risk recalls. Integrate with Slack or email via Apify webhooks to get alerts on new enforcement actions in your product category.

#### Medical Research and Academic Studies

Export large cohorts for epidemiological analysis. Cross-reference patient demographics (age, sex, country) with reaction profiles. The 20M+ record dataset enables population-level drug safety studies without direct FDA database access.

#### Competitive Intelligence for Pharma

Monitor adverse event reports for competitor drugs. Track changes in reporting rates over time. Compare safety profiles between drugs in the same therapeutic class using targeted search queries.

### 🔌 Automating OpenFDA Scraper

Connect this actor to your existing workflows with no code:

- **Make (Integromat)**: Schedule weekly runs and push results to Google Sheets or a database
- **Zapier**: Trigger email alerts when new recall records appear for specific firms
- **Slack**: Route FDA enforcement alerts to a compliance channel automatically
- **Google Sheets**: Export results directly into a shared team spreadsheet for analysis
- **Webhooks**: Receive a POST notification the moment each run completes

Use [Apify Schedules](https://docs.apify.com/schedules) to run this actor automatically on a cron schedule.

### 🌟 Beyond business use cases

#### Academic Research

Epidemiologists and pharmacologists can use the full adverse event dataset to study drug interactions, demographic risk factors, and reporting patterns across countries. The MedDRA reaction terms are standardized, making cross-study comparison straightforward.

#### Public Health Data Journalism

Journalists investigating drug safety can pull FDA data without filing FOIA requests. Cross-reference adverse event spikes with drug approval dates, recalls, or label changes to build data-driven investigative stories.

#### Non-Profit and Patient Advocacy

Patient advocacy groups can track reporting rates for conditions affecting their communities. Monitor whether adverse events for a specific drug category are rising or falling. Share findings with members, regulators, or press.

#### Learning and Experimentation

Data science students and bootcamp graduates can use this as a real-world dataset to practice time-series analysis, NLP on reaction terms, and classification models for serious-vs-non-serious outcomes.

### 🤖 Ask an AI assistant about this scraper

You can ask Claude, ChatGPT, or any AI assistant about this actor. Try:

- "How do I search for adverse events for a specific drug using this scraper?"
- "What openFDA search syntax filters for death outcomes only?"
- "How do I schedule this actor to run weekly and get results in Slack?"

### ❓ Frequently Asked Questions

#### ❓ Do I need an FDA API key?

No. The openFDA API is public and requires no authentication. This actor works with zero credentials.

#### ❓ How many records can I export?

Free users can export 10 records as a preview. Paid users can export up to 1,000,000 records per run.

#### ❓ Why is patientAge null on some records?

The FDA does not require reporters to include patient age. Many consumer-submitted reports omit it. This is expected and reflects the real source data.

#### ❓ What is the openFDA skip/pagination limit?

The openFDA API caps pagination at 25,000 records per query. To go beyond 25,000, use the `search` parameter to narrow results by drug, reaction, date range, or country - then run multiple queries.

#### ❓ What is MedDRA?

MedDRA (Medical Dictionary for Regulatory Activities) is the international standard for adverse event terminology. The `reactions` field contains MedDRA preferred terms, usable for cross-database comparisons.

#### ❓ How current is the data?

The openFDA database is updated weekly. Newly submitted adverse event reports typically appear within 1-2 weeks of FDA processing.

#### ❓ Can I filter by drug name?

Yes. Use the `search` field with: `patient.drug.medicinalproduct:"IBUPROFEN"` to filter for a specific drug.

#### ❓ Can I filter for death outcomes only?

Yes. Use `search: "seriousnessdeath:1"` to return only records where death was reported as an outcome.

#### ❓ What format are dates in?

Dates are normalized to ISO 8601 format (YYYY-MM-DD). The original FDA source uses YYYYMMDD which is automatically converted.

#### ❓ Does this cover international adverse event reports?

Yes. The FDA receives reports from healthcare providers, manufacturers, and consumers worldwide. The `reportCountry` field captures the reporter's country (2-letter ISO code).

#### ❓ What is the rate limit?

The public openFDA API allows 1,000 requests per day and 40 requests per minute without an API key. This actor is designed to stay well within limits.

#### ❓ Can I export food recalls?

Yes. Set `dataType` to `food_enforcement` to retrieve FDA food recall records including classification, recalling firm, and reason for recall.

### 🔌 Integrate with any app

This actor works with the entire Apify integration ecosystem. Export your dataset to:

**Storage and databases:** Google Sheets, Airtable, Notion, PostgreSQL, MySQL, MongoDB, Snowflake, BigQuery, AWS S3, Azure Blob Storage

**Automation platforms:** Make (Integromat), Zapier, n8n, Pipedream, Activepieces

**Communication tools:** Slack, Microsoft Teams, Discord, Email (SendGrid, Mailchimp)

**BI and analytics:** Tableau, Power BI, Looker, Metabase, Google Data Studio

**Custom integrations:** Apify API (REST), webhooks, Apify SDK

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [FDIC Bank Scraper](https://apify.com/parseforge/fdic-bank-scraper) | Export all FDIC-insured US banks with financial metrics |
| [USPTO Office Actions Scraper](https://apify.com/parseforge/uspto-office-actions-scraper) | Fetch US patent office actions from USPTO |
| [World Bank Scraper](https://apify.com/parseforge/world-bank-scraper) | Download World Bank development indicators |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more public-data scrapers across government, finance, jobs, and real estate.

***

*This actor accesses only publicly available data from the openFDA API (open.fda.gov). All data is provided by the US Food and Drug Administration under their open data terms. ParseForge is not affiliated with the FDA. Use of this data is subject to openFDA's terms of service.*

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `dataType` (type: `string`):

Which FDA dataset to query.

## `search` (type: `string`):

Optional openFDA search expression (e.g. patient.reaction.reactionmeddrapt:"headache" or recalling\_firm:"ABC Corp"). Leave blank to fetch all records.

## `startDate` (type: `string`):

Filter records received on or after this date. Only applies to drug\_events (uses receivedate field).

## `endDate` (type: `string`):

Filter records received on or before this date. Only applies to drug\_events.

## Actor input object example

```json
{
  "maxItems": 10,
  "dataType": "drug_events"
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10,
    "dataType": "drug_events"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openfda-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 = {
    "maxItems": 10,
    "dataType": "drug_events",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openfda-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 '{
  "maxItems": 10,
  "dataType": "drug_events"
}' |
apify call parseforge/openfda-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenFDA Drug Adverse Events & Recall Scraper",
        "description": "Scrape FDA drug adverse events, drug labels, and food enforcement recalls from the openFDA public API — no auth required.",
        "version": "0.1",
        "x-build-id": "wPqhavxBpBsdGD5wx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openfda-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openfda-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/parseforge~openfda-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openfda-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/parseforge~openfda-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openfda-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "drug_events",
                            "drug_labels",
                            "food_enforcement"
                        ],
                        "type": "string",
                        "description": "Which FDA dataset to query."
                    },
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional openFDA search expression (e.g. patient.reaction.reactionmeddrapt:\"headache\" or recalling_firm:\"ABC Corp\"). Leave blank to fetch all records."
                    },
                    "startDate": {
                        "title": "Start Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Filter records received on or after this date. Only applies to drug_events (uses receivedate field)."
                    },
                    "endDate": {
                        "title": "End Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Filter records received on or before this date. Only applies to drug_events."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
