# openFDA 510(k) Device Clearances Scraper (`automation-lab/openfda-510k-device-clearances-scraper`) Actor

Export FDA 510(k) medical device clearance records by applicant, product code, k-number, decision date, and clearance metadata.

- **URL**: https://apify.com/automation-lab/openfda-510k-device-clearances-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, Automation
- **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

## openFDA 510(k) Device Clearances Scraper

Export FDA 510(k) medical device clearance records from the public openFDA API.

Use this actor to monitor cleared medical devices, track competitors, build regulatory intelligence dashboards, or enrich compliance workflows with structured FDA 510(k) data.

### What does openFDA 510(k) Device Clearances Scraper do?

This actor searches the openFDA `device/510k` dataset and saves normalized 510(k) clearance records to an Apify dataset.

It can export records by applicant, device name, product code, k-number, FDA decision date, received date, decision code, or a raw openFDA query.

Each output item includes normalized fields and direct links back to FDA and openFDA records.

### Who is it for?

- 🏥 **Medtech regulatory affairs teams** monitoring new clearances in their product areas.
- 📊 **Competitive intelligence analysts** tracking competitors by applicant, product code, and clearance date.
- 💼 **Investors and consultants** researching device markets, clearance cadence, and sponsor activity.
- ⚖️ **Compliance and product-liability teams** reviewing historical FDA device clearance metadata.
- 🧪 **Data teams** building repeatable FDA data pipelines on Apify.

### Why use this actor?

The openFDA API is public, but raw API calls require users to build query strings, paginate, normalize fields, and manage exports.

This actor turns the API into a ready-to-run Apify workflow with clean input fields, dataset export, API access, integrations, and pay-per-result pricing.

### Key features

- 🔎 Search FDA 510(k) clearances by company, device, product code, or k-number.
- 📅 Filter by decision date and FDA received date.
- 🧾 Export normalized regulatory metadata.
- 🔗 Save direct FDA record URLs and openFDA API URLs.
- 🧰 Keep optional raw FDA JSON for audits.
- ⚡ HTTP-only implementation; no browser or proxy required.

### Data table

| Field | Description |
| --- | --- |
| `kNumber` | FDA 510(k) number such as `K240001` |
| `applicant` | Applicant or manufacturer name |
| `deviceName` | Cleared device name |
| `productCode` | FDA product code |
| `decisionDate` | FDA decision date |
| `decisionDescription` | Human-readable FDA decision description |
| `clearanceType` | Clearance type from openFDA |
| `dateReceived` | Date FDA received the submission |
| `advisoryCommitteeDescription` | Committee or medical specialty text |
| `recordUrl` | Direct FDA record page |
| `apiUrl` | Direct openFDA API URL for the record |
| `raw` | Optional original openFDA record |

### How much does it cost to scrape FDA 510(k) clearances?

The actor uses pay-per-event pricing:

- **Run started:** $0.005 once per run.
- **510(k) clearance record extracted:** tiered per-record pricing, starting at $0.000025187 per saved record on the Free tier and decreasing on paid Apify plans.
- Higher Apify subscription tiers receive discounted per-record pricing.

Estimated actor charges on the Free tier:

| Records exported | Estimated charge |
| ---: | ---: |
| 20 records | ~$0.0055 |
| 100 records | ~$0.0075 |
| 150 records | ~$0.0088 |

Free-plan estimate: with $5 of available Apify usage credit, 100-record runs would cover roughly **650 runs / 65,000 records** at the current Free-tier actor price, before any separate Apify platform usage costs or account-level limits.

Because the source is a public API and the actor does not use a browser or proxy, runs are designed to stay inexpensive.

### How to use it

1. Open the actor on Apify.
2. Enter a company name such as `Medtronic` in **Applicant / company**.
3. Optionally add a product code, device name, or date range.
4. Keep **Maximum records** low for a first test run.
5. Start the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Raw openFDA search query

Use `search` when you already know openFDA query syntax.

Example:

```text
applicant:"MEDTRONIC"+AND+product_code:"DQY"
````

#### Applicant / company

Filter by applicant name.

Examples:

- `Medtronic`
- `Abbott`
- `Boston Scientific`

#### Device name

Filter by device name text.

Examples:

- `stent`
- `catheter`
- `implant`

#### Product code

Filter by FDA product code.

Examples:

- `DQY`
- `MNI`
- `OYC`

#### 510(k) number

Export one specific clearance by k-number.

Example:

```json
{ "kNumber": "K240001" }
```

#### Date filters

Use decision-date filters for market monitoring and received-date filters for workflow analysis.

Dates can be entered as `YYYY-MM-DD` or `YYYYMMDD`.

#### Include raw FDA record

Enable `includeRaw` when you need every original openFDA field for validation, legal review, or custom downstream processing.

### Output example

```json
{
  "kNumber": "K240001",
  "applicant": "EXAMPLE MEDICAL INC.",
  "deviceName": "Example Device",
  "productCode": "ABC",
  "decisionDate": "20240115",
  "decisionDescription": "Substantially Equivalent",
  "dateReceived": "20231001",
  "recordUrl": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K240001",
  "source": "openFDA device/510k"
}
```

### Tips for better results

- ✅ Start with a company and date range before running large exports.
- ✅ Use product codes for focused market maps.
- ✅ Use k-number mode when you need one exact clearance.
- ✅ Enable raw records only when needed because it increases dataset size.
- ✅ Use recent decision dates for monitoring workflows.

### Integrations

You can connect this actor to:

- Google Sheets for weekly clearance trackers.
- Airtable for medtech competitive intelligence.
- Slack or email alerts for new product-code clearances.
- BI tools for clearance timelines and applicant dashboards.
- Internal regulatory data lakes via the 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/openfda-510k-device-clearances-scraper').call({
  applicant: 'Medtronic',
  decisionDateFrom: '2024-01-01',
  maxResults: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/openfda-510k-device-clearances-scraper').call(run_input={
    'applicant': 'Medtronic',
    'decisionDateFrom': '2024-01-01',
    'maxResults': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~openfda-510k-device-clearances-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"applicant":"Medtronic","decisionDateFrom":"2024-01-01","maxResults":100}'
```

### MCP integration

Use the actor through Apify MCP from Claude Desktop, Claude Code, Cursor, VS Code, and other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/openfda-510k-device-clearances-scraper
```

Claude Code setup:

```bash
claude mcp add apify-openfda-510k --transport http "https://mcp.apify.com/?tools=automation-lab/openfda-510k-device-clearances-scraper"
```

Claude Desktop, Cursor, and VS Code JSON config:

```json
{
  "mcpServers": {
    "apify-openfda-510k": {
      "url": "https://mcp.apify.com/?tools=automation-lab/openfda-510k-device-clearances-scraper"
    }
  }
}
```

Example prompts:

- "Export 100 recent FDA 510(k) clearances for Medtronic."
- "Find cleared devices for product code DQY since 2024."
- "Monitor new Abbott 510(k) decisions and summarize the device names."

### Common workflows

#### Competitor monitoring

Run weekly with applicant filters for known competitors.

#### Product-code market mapping

Run by product code and decision date to understand clearance velocity.

#### Single-record enrichment

Run by k-number to enrich CRM, claims, or product-intelligence records.

#### Regulatory dashboard refresh

Schedule runs and export the dataset to BI or a data warehouse.

### Limitations

- The actor depends on openFDA availability and openFDA query syntax.
- Very large whole-database exports may require multiple runs.
- Some FDA fields are sparse because the source record may omit them.
- The actor does not interpret legal meaning; it exports source metadata.

### Legality

This actor uses the public openFDA API for FDA public records. Users are responsible for complying with applicable laws, internal policies, openFDA terms, and Apify terms.

The dataset may be used for research, monitoring, and analytics, but it should not be treated as legal, medical, or regulatory advice.

### FAQ

#### Does it require an FDA API key?

No. The actor works with the public openFDA API without an API key for normal usage.

#### Does it use proxies?

No. The source is a public API, so the actor does not require a proxy by default.

#### Why did my query fail?

Raw openFDA queries must use valid openFDA search syntax. Try using the structured input fields first, then move to raw query mode.

#### Why are some fields empty?

The FDA source record does not always contain every field. Empty values usually mean the source omitted that metadata.

### Related scrapers

- https://apify.com/automation-lab/fda-maude-adverse-event-reports-scraper
- https://apify.com/automation-lab/fda-orange-book-scraper
- https://apify.com/automation-lab/openfda-510k-device-clearances-scraper

### Support

If you need an additional field, filter, or export format, open an issue on the actor page and include a sample k-number or query.

### Changelog

Initial version exports normalized FDA 510(k) clearance records from openFDA.

# Actor input Schema

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

Optional advanced openFDA search expression, for example applicant:"MEDTRONIC" or device\_name:stent. Field filters below are combined with AND.

## `applicant` (type: `string`):

Medical device applicant or manufacturer name, for example Medtronic, Abbott, or Boston Scientific.

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

Filter by 510(k) device name.

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

FDA product code, for example DQY, MNI, or OYC.

## `kNumber` (type: `string`):

Specific k\_number such as K240001.

## `decisionCode` (type: `string`):

FDA decision code, for example SESE (substantially equivalent).

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

Inclusive decision date start in YYYY-MM-DD or YYYYMMDD format.

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

Inclusive decision date end in YYYY-MM-DD or YYYYMMDD format.

## `dateReceivedFrom` (type: `string`):

Inclusive FDA received-date start in YYYY-MM-DD or YYYYMMDD format.

## `dateReceivedTo` (type: `string`):

Inclusive FDA received-date end in YYYY-MM-DD or YYYYMMDD format.

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

Maximum number of 510(k) clearance records to save. The default is low for a cheap first run.

## `sort` (type: `string`):

Sort records before exporting.

## `includeRaw` (type: `boolean`):

Attach the original openFDA JSON record to each output item for audits and custom processing.

## Actor input object example

```json
{
  "applicant": "Medtronic",
  "decisionDateFrom": "2024-01-01",
  "maxResults": 20,
  "sort": "decision_date_desc",
  "includeRaw": false
}
```

# 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 = {
    "search": "",
    "applicant": "Medtronic",
    "decisionDateFrom": "2024-01-01",
    "maxResults": 20,
    "sort": "decision_date_desc",
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/openfda-510k-device-clearances-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 = {
    "search": "",
    "applicant": "Medtronic",
    "decisionDateFrom": "2024-01-01",
    "maxResults": 20,
    "sort": "decision_date_desc",
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/openfda-510k-device-clearances-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 '{
  "search": "",
  "applicant": "Medtronic",
  "decisionDateFrom": "2024-01-01",
  "maxResults": 20,
  "sort": "decision_date_desc",
  "includeRaw": false
}' |
apify call automation-lab/openfda-510k-device-clearances-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "openFDA 510(k) Device Clearances Scraper",
        "description": "Export FDA 510(k) medical device clearance records by applicant, product code, k-number, decision date, and clearance metadata.",
        "version": "0.1",
        "x-build-id": "5j0yYbBhQ8RjiX8rZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~openfda-510k-device-clearances-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-openfda-510k-device-clearances-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~openfda-510k-device-clearances-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-openfda-510k-device-clearances-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~openfda-510k-device-clearances-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-openfda-510k-device-clearances-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": {
                    "search": {
                        "title": "Raw openFDA search query",
                        "type": "string",
                        "description": "Optional advanced openFDA search expression, for example applicant:\"MEDTRONIC\" or device_name:stent. Field filters below are combined with AND."
                    },
                    "applicant": {
                        "title": "Applicant / company",
                        "type": "string",
                        "description": "Medical device applicant or manufacturer name, for example Medtronic, Abbott, or Boston Scientific."
                    },
                    "deviceName": {
                        "title": "Device name contains",
                        "type": "string",
                        "description": "Filter by 510(k) device name."
                    },
                    "productCode": {
                        "title": "Product code",
                        "type": "string",
                        "description": "FDA product code, for example DQY, MNI, or OYC."
                    },
                    "kNumber": {
                        "title": "510(k) number",
                        "type": "string",
                        "description": "Specific k_number such as K240001."
                    },
                    "decisionCode": {
                        "title": "Decision code",
                        "type": "string",
                        "description": "FDA decision code, for example SESE (substantially equivalent)."
                    },
                    "decisionDateFrom": {
                        "title": "Decision date from",
                        "type": "string",
                        "description": "Inclusive decision date start in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "decisionDateTo": {
                        "title": "Decision date to",
                        "type": "string",
                        "description": "Inclusive decision date end in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "dateReceivedFrom": {
                        "title": "Date received from",
                        "type": "string",
                        "description": "Inclusive FDA received-date start in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "dateReceivedTo": {
                        "title": "Date received to",
                        "type": "string",
                        "description": "Inclusive FDA received-date end in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of 510(k) clearance records to save. The default is low for a cheap first run.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "decision_date_desc",
                            "decision_date_asc",
                            "date_received_desc",
                            "date_received_asc",
                            "none"
                        ],
                        "type": "string",
                        "description": "Sort records before exporting.",
                        "default": "decision_date_desc"
                    },
                    "includeRaw": {
                        "title": "Include raw FDA record",
                        "type": "boolean",
                        "description": "Attach the original openFDA JSON record to each output item for audits and custom processing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```