# FDA De Novo Device Decisions Scraper (`automation-lab/fda-de-novo-device-decisions-scraper`) Actor

Extract official FDA De Novo device decisions for regulatory monitoring, including requesters, product codes, committees, PCCP status, and source documents.

- **URL**: https://apify.com/automation-lab/fda-de-novo-device-decisions-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## FDA De Novo Device Decisions Scraper

Turn the FDA De Novo database into structured regulatory intelligence.

Search recent decisions or look up known `DEN######` records, enrich every match from its official detail page, and export the results as JSON, CSV, Excel, XML, or RSS through Apify.

This Actor is built for recurring monitoring as well as one-off device research.

### What does FDA De Novo Device Decisions Scraper do?

The Actor reads the public FDA Device Classification Under Section 513(f)(2) database.

It can:

- 🔎 search decisions by requester, device, product code, panel, date, or PCCP status;
- 🎯 look up one or more known De Novo numbers;
- 🧾 enrich search rows with regulation and committee details;
- 🔗 retain official classification-order and decision-summary PDF links;
- 📤 deliver typed records in an Apify dataset;
- ⏰ run on a schedule for repeat monitoring.

Each dataset row represents one FDA De Novo classification decision.

### Why use this FDA De Novo scraper?

FDA's search interface is useful for individual lookups, but recurring analysis requires repeatable structured output.

This Actor removes manual copying and joins list-page data with detail-page fields.

Use it to build a decision feed, compare pathways, watch competitors, identify newly created product codes, or populate a regulatory research warehouse.

The source remains the official FDA record, and every row includes its source URL.

### Who is it for?

#### Regulatory affairs teams

Monitor grants, review committees, submission types, and document availability.

#### Medtech competitive-intelligence teams

Track competitor requesters, novel devices, linked 510(k)s, and emerging product codes.

#### Investors and strategy teams

Build a time series of novel-device decisions and examine category activity.

#### Consultants and researchers

Export consistent records across clients, panels, dates, and product areas.

#### Data engineers

Schedule the Actor and send results to a database, spreadsheet, webhook, or cloud workflow.

### What FDA De Novo data can you extract?

| Field | Meaning |
|---|---|
| `deNovoNumber` | FDA De Novo identifier |
| `deviceName` | Submitted device or trade name |
| `deviceClassificationName` | FDA classification name |
| `requester` | Requesting company or organization |
| `requesterAddress` | Address shown by FDA |
| `contact` | Public contact shown by FDA |
| `linked510kNumber` | Related 510(k), when listed |
| `regulationNumber` | Applicable regulation number |
| `productCodes` | FDA product classification codes |
| `dateReceived` | Date FDA received the request |
| `decisionDate` | Decision date |
| `decision` | FDA decision text and code |
| `submissionType` | Direct or other submission type |
| `classificationAdvisoryCommittee` | Classification committee |
| `reviewAdvisoryCommittee` | Review committee |
| `pccpAuthorized` | Predetermined Change Control Plan authorization |
| `classificationOrderUrl` | Official classification-order PDF |
| `decisionSummaryUrl` | Official FDA decision-summary PDF |
| `sourceUrl` | FDA detail page |
| `scrapedAt` | Extraction timestamp |

Fields that FDA does not publish for a record are omitted rather than guessed.

### How to scrape FDA De Novo decisions

1. Open the Actor in Apify Console.
2. Keep the prefilled `DEN230041` for a quick lookup, or clear it to use search filters.
3. Set a low `maxItems` while testing a workflow.
4. Click **Start**.
5. Open the default dataset when the run succeeds.
6. Export the data or connect it to another service.

A one-record prefilled run is suitable for validating your setup.

### Input options

#### De Novo numbers

Provide values such as:

```json
["DEN230041", "DEN210003"]
````

Identifiers must start with `DEN` and contain six digits.

#### FDA detail URLs

You can provide official URLs ending in `denovo.cfm?ID=DEN######`.

URLs outside the FDA De Novo detail surface are rejected.

#### Search filters

Leave both direct-input fields empty to search.

Available filters include:

- requester name;
- device name;
- three-letter product code;
- advisory panel;
- decision date from and to;
- PCCP authorization.

#### Maximum decisions

`maxItems` controls how many detail records are enriched and saved.

The allowed range is 1–500.

#### Proxy configuration

The FDA blocks some data-center egress.

The Actor defaults to Apify's US SHADER proxy group and rotates sessions on FDA anti-bot responses.

You can select another available group in the standard proxy editor.

### Input examples

#### Look up one known decision

```json
{
  "deNovoNumbers": ["DEN230041"],
  "maxItems": 1
}
```

#### Search recent decisions

```json
{
  "deNovoNumbers": [],
  "decisionDateFrom": "01/01/2026",
  "decisionDateTo": "07/21/2026",
  "maxItems": 25
}
```

#### Search one product code

```json
{
  "deNovoNumbers": [],
  "productCode": "QZW",
  "maxItems": 10
}
```

#### Find PCCP-authorized decisions

```json
{
  "deNovoNumbers": [],
  "pccpAuthorized": "yes",
  "maxItems": 50
}
```

### Output example

```json
{
  "deNovoNumber": "DEN230041",
  "deviceName": "Sleep Apnea Feature",
  "deviceClassificationName": "over-the-counter device to assess risk of sleep apnea",
  "requester": "samsung electronics co., ltd.",
  "contact": "hon pak",
  "regulationNumber": "868.2378",
  "productCodes": ["QZW"],
  "dateReceived": "05/31/2023",
  "decisionDate": "02/06/2024",
  "decision": "granted (DENG)",
  "submissionType": "Direct",
  "classificationAdvisoryCommittee": "Anesthesiology",
  "reviewAdvisoryCommittee": "Anesthesiology",
  "pccpAuthorized": false,
  "classificationOrderUrl": "https://www.accessdata.fda.gov/cdrh_docs/pdf23/DEN230041.pdf",
  "decisionSummaryUrl": "https://www.accessdata.fda.gov/cdrh_docs/reviews/DEN230041.pdf"
}
```

Values reflect the FDA page at extraction time.

### How much does it cost to scrape FDA De Novo decisions?

The Actor uses pay-per-event pricing.

A small start charge covers run initialization, and each successfully saved enriched decision creates one item charge.

Failed pages are not emitted as paid dataset items.

Your Apify pricing tier determines the item rate shown in Console.

Start with one to ten records to estimate workflow cost before scheduling a larger monitor.

### Accuracy and data quality

The parser uses FDA's visible field labels rather than relying on column positions in the detail table.

Required identity and decision fields must exist before a record is saved.

The Actor deduplicates De Novo numbers returned by search.

It preserves the official record URL and extraction timestamp for auditing.

It does not infer clinical claims, approval status, or market authorization beyond FDA's published decision text.

### Monitoring new FDA decisions

Create a scheduled Apify task with:

- direct identifiers cleared;
- a rolling or recent decision-date range;
- a practical `maxItems` cap;
- dataset or webhook integration enabled.

For durable incremental monitoring, send completed datasets to your own store and deduplicate on `deNovoNumber`.

Weekly monitoring is often sufficient for regulatory intelligence workflows.

### Tips for reliable runs

- Keep the default proxy enabled.
- Use exact `DEN######` lookups when you already know identifiers.
- Use `MM/DD/YYYY` for date filters.
- Keep initial result limits low.
- Treat PDF links as source documents, not extracted PDF text.
- Retry later if FDA is undergoing maintenance.
- Schedule at conservative frequency to respect the public source.

### Integrations

#### Google Sheets

Use the Google Sheets integration to append newly observed decisions to a tracker.

#### Slack or Microsoft Teams

Send a webhook when a scheduled run contains a new De Novo number.

#### Airtable or a CRM

Map requester and device fields into an account or market-intelligence table.

#### Data warehouses

Load JSON or CSV into BigQuery, Snowflake, Redshift, or PostgreSQL.

#### Make and Zapier

Trigger downstream workflows after a run succeeds.

#### Webhooks

Attach a run-succeeded webhook and fetch the default dataset through the API.

### Use with the Apify API in Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fda-de-novo-device-decisions-scraper').call({
  deNovoNumbers: ['DEN230041'],
  maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with the Apify API in Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/fda-de-novo-device-decisions-scraper").call(
    run_input={"deNovoNumbers": ["DEN230041"], "maxItems": 1}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fda-de-novo-device-decisions-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"deNovoNumbers":["DEN230041"],"maxItems":1}'
```

Read the resulting default dataset after the run completes.

### Use through Apify MCP

Connect the Actor to an AI assistant through:

`https://mcp.apify.com/?tools=automation-lab/fda-de-novo-device-decisions-scraper`

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/fda-de-novo-device-decisions-scraper"
```

#### Claude Desktop

Add this server under `mcpServers` in Claude Desktop's configuration:

```json
{
  "mcpServers": {
    "apify-fda-denovo": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fda-de-novo-device-decisions-scraper"
    }
  }
}
```

#### Cursor

Add the same `mcpServers` JSON in **Cursor Settings → MCP**, then authenticate with Apify when prompted.

#### VS Code

Open **MCP: Add Server** from the command palette, choose HTTP, and paste the MCP URL above.

Example prompts:

- “Look up FDA De Novo record DEN230041 and summarize the regulatory pathway.”
- “Find 2026 De Novo decisions for neurology devices and return official document links.”
- “Compare requester and product-code activity in the latest FDA De Novo records.”

Always verify consequential conclusions against the linked FDA documents.

### Error handling

Invalid identifiers and unsupported URLs fail before scraping.

The Actor rotates proxy sessions when FDA returns a 403 or apology page.

A search with no matches fails with a clear message instead of silently returning misleading success.

If every detail extraction fails, the run exits non-zero.

Partial data is saved only when required fields are present.

### Legal and ethical use

This Actor accesses publicly available U.S. Food and Drug Administration records.

Use it responsibly, at conservative frequency, and in accordance with Apify's terms and applicable law.

FDA records may be corrected after publication.

Do not treat Actor output as medical, clinical, investment, or legal advice.

Review original FDA pages and documents before making decisions.

This Actor is independent and is not affiliated with or endorsed by the FDA.

### Frequently asked questions

#### Is a De Novo grant the same as a 510(k) clearance?

No. They are different FDA pathways. This Actor reports the source decision text and linked 510(k) number when FDA provides one.

#### Does the Actor download or parse PDFs?

No. It preserves classification-order and decision-summary URLs. Use a separate PDF extraction workflow if document text is required.

#### Why did my filtered search return no records?

Check spelling, use `MM/DD/YYYY`, clear direct De Novo numbers, and broaden one filter at a time. No-match searches fail clearly.

#### Why was an FDA request blocked?

FDA uses egress-sensitive anti-bot controls. Keep Apify proxy enabled; the Actor rotates sessions automatically on recognized blocks.

#### Can I monitor only new records?

Schedule a date-filtered task and deduplicate completed datasets by `deNovoNumber` in your downstream store.

#### Are all output fields always present?

No. Older or unusual FDA records may omit linked 510(k)s, contacts, PCCP status, or documents.

#### Can I search more than 500 records?

A run is capped at 500 enriched records. Split large historical work into bounded date ranges.

### Related scrapers

- [OpenFDA 510(k) Device Clearances Scraper](https://apify.com/automation-lab/openfda-510k-device-clearances-scraper) for the distinct 510(k) clearance pathway.
- [OpenFDA Drug NDC Directory Scraper](https://apify.com/automation-lab/openfda-drug-ndc-directory-scraper) for drug product directory data.
- [OpenFDA Scraper](https://apify.com/automation-lab/openfda-scraper) for supported openFDA datasets.

Choose this Actor when the entity of interest is specifically an FDA De Novo classification decision.

### Support

If a valid FDA De Novo record is missing a published field, open an issue from the Actor page.

Include the De Novo number, input, run ID, and expected FDA field.

Do not include confidential medical or business information.

Source-page changes can then be reproduced and addressed precisely.

# Actor input Schema

## `deNovoNumbers` (type: `array`):

FDA identifiers such as DEN230041. Leave empty to use search filters.

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

Optional accessdata.fda.gov denovo.cfm?ID=DEN… detail URLs.

## `requester` (type: `string`):

Match the FDA requester/applicant name.

## `deviceName` (type: `string`):

Match words in the device name.

## `productCode` (type: `string`):

FDA three-letter product code, for example QZW.

## `panel` (type: `string`):

FDA panel name, for example Neurology.

## `decisionDateFrom` (type: `string`):

Inclusive MM/DD/YYYY lower bound.

## `decisionDateTo` (type: `string`):

Inclusive MM/DD/YYYY upper bound.

## `pccpAuthorized` (type: `string`):

Filter by Predetermined Change Control Plan authorization.

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

Maximum enriched decision records to save.

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

Apify proxy is recommended because FDA blocks some data-center egress.

## Actor input object example

```json
{
  "deNovoNumbers": [
    "DEN230041"
  ],
  "pccpAuthorized": "",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "deNovoNumbers": [
        "DEN230041"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fda-de-novo-device-decisions-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 = {
    "deNovoNumbers": ["DEN230041"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fda-de-novo-device-decisions-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 '{
  "deNovoNumbers": [
    "DEN230041"
  ],
  "maxItems": 10
}' |
apify call automation-lab/fda-de-novo-device-decisions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA De Novo Device Decisions Scraper",
        "description": "Extract official FDA De Novo device decisions for regulatory monitoring, including requesters, product codes, committees, PCCP status, and source documents.",
        "version": "0.1",
        "x-build-id": "edC3QyMlZyKc04XeF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fda-de-novo-device-decisions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fda-de-novo-device-decisions-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~fda-de-novo-device-decisions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fda-de-novo-device-decisions-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~fda-de-novo-device-decisions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fda-de-novo-device-decisions-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": {
                    "deNovoNumbers": {
                        "title": "De Novo numbers",
                        "type": "array",
                        "description": "FDA identifiers such as DEN230041. Leave empty to use search filters.",
                        "default": [
                            "DEN230041"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "FDA De Novo detail URLs",
                        "type": "array",
                        "description": "Optional accessdata.fda.gov denovo.cfm?ID=DEN… detail URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "requester": {
                        "title": "Requester name",
                        "type": "string",
                        "description": "Match the FDA requester/applicant name."
                    },
                    "deviceName": {
                        "title": "Device name",
                        "type": "string",
                        "description": "Match words in the device name."
                    },
                    "productCode": {
                        "title": "Product code",
                        "pattern": "^[A-Za-z]{3}$",
                        "type": "string",
                        "description": "FDA three-letter product code, for example QZW."
                    },
                    "panel": {
                        "title": "Advisory panel",
                        "type": "string",
                        "description": "FDA panel name, for example Neurology."
                    },
                    "decisionDateFrom": {
                        "title": "Decision date from",
                        "pattern": "^(0[1-9]|1[0-2])/(0[1-9]|[12][0-9]|3[01])/\\d{4}$",
                        "type": "string",
                        "description": "Inclusive MM/DD/YYYY lower bound."
                    },
                    "decisionDateTo": {
                        "title": "Decision date to",
                        "pattern": "^(0[1-9]|1[0-2])/(0[1-9]|[12][0-9]|3[01])/\\d{4}$",
                        "type": "string",
                        "description": "Inclusive MM/DD/YYYY upper bound."
                    },
                    "pccpAuthorized": {
                        "title": "PCCP authorized",
                        "enum": [
                            "",
                            "yes",
                            "no"
                        ],
                        "type": "string",
                        "description": "Filter by Predetermined Change Control Plan authorization.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum decisions",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum enriched decision records to save.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy is recommended because FDA blocks some data-center egress.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "SHADER"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
