# Drugs.com Scraper | Medication Database (`parseforge/drugs-com-scraper`) Actor

Extract drug data from Drugs.com including name, brand, generic equivalents, dosage, side effects, interactions, warnings, contraindications, and user reviews. Build pharma datasets, medical apps, drug interaction checkers, and healthcare research tools with comprehensive info.

- **URL**: https://apify.com/parseforge/drugs-com-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Lead generation
- **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)

## 💊 Drugs.com Medication Scraper

> 🚀 **Export drug and medication information from Drugs.com in seconds.** Get drug class, generic names, brand names, descriptions, warnings, side effects, and FDA approval status - no login required.

> 🕒 **Last updated:** 2026-05-22 · **📊 13 fields** per record · **26 letters / 24,000+ drugs** · **Global coverage**

The Drugs.com Medication Scraper extracts structured pharmaceutical data directly from Drugs.com, the web's most-visited drug information resource. All data is collected in real-time from public pages - no account, no API key, no subscription needed.

Drugs.com provides patient-friendly drug monographs sourced from Micromedex, Cerner Multum, and ASHP - three of the most authoritative pharmaceutical databases in the world. This actor gives you structured access to that information at scale.

**Coverage:** 26 letters of the alphabet, 24,000+ drug and medication records, with 13 data fields per record including drug class, generic and brand names, warnings summary, side effects, dosage forms, CSA schedule, pregnancy risk, and FDA availability status.

**Target Audience / Use Cases**

| Audience | Use Case |
|---|---|
| Healthcare App Developers | Build drug lookup features backed by real Drugs.com data |
| Pharmaceutical Researchers | Collect structured drug metadata across therapeutic classes |
| Medical Information Platforms | Populate drug databases with descriptions and warnings |
| Academic Researchers | Analyze drug class distribution, controlled substance schedules |
| Health Journalists | Research drug profiles, brand vs. generic availability |
| Compliance Teams | Audit drug approval statuses and controlled substance classifications |

---

### 📋 What the Drugs.com Medication Scraper does

- Browses the Drugs.com A-Z drug directory by letter (a-z)
- Or accepts a custom list of specific drug names to look up directly
- Fetches each drug detail page and extracts structured information
- Returns generic name, all brand names, drug class, and description
- Captures warnings summary and side effects summary from the monograph
- Includes FDA availability status (Rx, OTC, or Rx/OTC), pregnancy risk data, and DEA CSA schedule
- Extracts available dosage forms (tablets, capsules, injection, etc.)
- Identifies what conditions each drug is indicated for (treatment guides)

> 💡 **Why it matters:** Drugs.com is the most-visited drug information website in the world, trusted by patients, pharmacists, and healthcare providers. This actor gives developers and researchers structured, machine-readable access to that information.

---

### 🎬 Full Demo

🚧 Coming soon

---

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startLetter` | select (a-z) | `a` | Letter of the alphabet to browse |
| `maxItems` | integer | `10` | Maximum number of drug records to return |
| `drugNames` | string list | - | Optional: specific drug names to look up directly |

**Example 1 - Browse by letter:**
```json
{
  "startLetter": "a",
  "maxItems": 50
}
````

**Example 2 - Specific drugs:**

```json
{
  "drugNames": ["aspirin", "ibuprofen", "metformin"],
  "maxItems": 10
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 results. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to scrape up to 1,000,000 items. When `drugNames` is provided, it overrides `startLetter`.

***

### 📊 Output

| Field | Type | Example |
|---|---|---|
| 💊 `name` | string | `"Aspirin"` |
| 🔗 `url` | string | `"https://www.drugs.com/aspirin.html"` |
| 🧪 `genericName` | string | `"aspirin (oral)"` |
| 🏷️ `brandNames` | array | `["Arthritis Pain", "Bayer Aspirin", "Ecotrin"]` |
| 🏥 `drugClass` | string | `"Platelet aggregation inhibitors, Salicylates"` |
| 📝 `description` | string | `"Aspirin is a salicylate..."` |
| 🎯 `usedFor` | array | `["Heart Attack", "Angina", "Pain Relief"]` |
| ⚠️ `warningsSummary` | string | `"Do not use if you have a bleeding disorder..."` |
| 🩺 `sideEffectsSummary` | string | `"Common side effects may include upset stomach..."` |
| 💉 `availableForms` | string | `"tablets (81 mg, 325 mg, 500 mg)"` |
| ✅ `approvalStatus` | string | `"Rx and/or OTC"` |
| 🤰 `pregnancyCategory` | string | `"Risk data available"` |
| 🔒 `csaSchedule` | string | `"Not a controlled drug (N/A)"` |
| 🕒 `scrapedAt` | string | `"2026-05-22T02:08:06.066Z"` |
| ❌ `error` | string|null | `null` |

**Sample Records:**

```json
[
  {
    "name": "Aspirin",
    "url": "https://www.drugs.com/aspirin.html",
    "genericName": "aspirin (oral)",
    "brandNames": ["Arthritis Pain", "Aspir 81", "Aspir-Low", "Bayer Plus"],
    "drugClass": "Platelet aggregation inhibitors, Salicylates",
    "description": "Aspirin is a salicylate (sa-LIS-il-ate). It works by reducing substances in the body that cause pain, fever, and inflammation.",
    "usedFor": ["Heart Attack", "Angina", "Ankylosing Spondylitis"],
    "warningsSummary": "You should not use aspirin if you have a bleeding disorder such as hemophilia...",
    "sideEffectsSummary": "Get emergency medical help if you have signs of an allergic reaction to aspirin...",
    "availableForms": "oral tablet (81 mg; 325 mg; 500 mg)",
    "approvalStatus": "Rx and/or OTC",
    "pregnancyCategory": "Risk data available",
    "csaSchedule": "Not a controlled drug (N/A)",
    "scrapedAt": "2026-05-22T02:08:09.000Z",
    "error": null
  },
  {
    "name": "Abiraterone",
    "url": "https://www.drugs.com/abiraterone.html",
    "genericName": "abiraterone acetate",
    "brandNames": ["Yonsa", "Zytiga"],
    "drugClass": "Miscellaneous antineoplastics",
    "description": "Abiraterone works by reducing androgen production in the body...",
    "usedFor": ["Prostate Cancer"],
    "warningsSummary": "Abiraterone tablets should not be handled by a woman who is pregnant...",
    "sideEffectsSummary": "Get emergency medical help if you have signs of an allergic reaction...",
    "availableForms": "oral tablet (125 mg; 250 mg; 500 mg)",
    "approvalStatus": "Prescription only",
    "pregnancyCategory": "Risk data available",
    "csaSchedule": "Not a controlled drug (N/A)",
    "scrapedAt": "2026-05-22T02:08:10.000Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 📡 Real-time data | All data scraped live - no stale cache |
| 🌐 Full A-Z coverage | Scrape all 24,000+ drugs across all letters |
| 🎯 Targeted lookups | Provide specific drug names for direct extraction |
| 🧪 Structured output | 13 clean fields per record, ready for analysis |
| 🏥 Healthcare-grade source | Powered by Micromedex, Cerner Multum, and ASHP data |
| ⚡ Fast execution | 5 drugs in under 5 seconds on cloud |
| 🔒 No login required | 100% public data - no account needed |

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Other scrapers |
|---|---|---|---|
| Real-time data | Yes | Yes | Varies |
| Structured 13-field output | Yes | No | Rarely |
| A-Z full directory support | Yes | No | No |
| Drug class extraction | Yes | Manually | No |
| CSA schedule | Yes | Manually | No |
| Pregnancy risk | Yes | Manually | No |
| Dosage forms | Yes | Manually | No |
| Scalable to 24,000+ drugs | Yes | No | No |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 free credit)
2. Open the **Drugs.com Medication Scraper** actor
3. Set `startLetter` to the letter you want to browse, or enter specific `drugNames`
4. Set `maxItems` to control how many records to return
5. Click **Start** - your dataset will be ready in seconds
6. Download your results as JSON, CSV, Excel, or XML

***

### 💼 Business use cases

#### 1. Healthcare Application Development

Build drug lookup features, formulary checkers, or medication guides powered by live Drugs.com data. Get structured fields (generic name, brand names, drug class, warnings) that plug directly into your database.

#### 2. Pharmaceutical Research and Market Analysis

Analyze the composition of drug classes - how many NSAIDs vs. SSRIs vs. statins exist? Which brand names dominate which therapeutic categories? Monitor newly approved drugs by scraping the directory regularly.

#### 3. Medical Information and Patient Safety Systems

Populate or update drug databases with descriptions, warnings summaries, and side effects. Build patient-facing tools that surface concise, accurate drug information from a trusted source.

#### 4. Regulatory and Compliance Workflows

Track DEA CSA schedule classifications and FDA approval statuses across drug portfolios. Quickly identify which products are controlled substances (Schedule II-V) vs. non-controlled.

***

### 🔌 Automating Drugs.com Medication Scraper

Connect this actor to your workflows using Apify integrations:

- **Make (formerly Integromat)** - Trigger on a schedule, send results to Google Sheets or Airtable
- **Zapier** - Push new drug records to Slack, Notion, or any CRM
- **Slack** - Get notifications when a scrape completes with item counts
- **Google Sheets** - Auto-populate drug databases via the Apify Google Sheets integration
- **REST API** - Call from any application using the Apify REST API

***

### 🌟 Beyond business use cases

#### Academic Research

Study drug class distribution across the pharmacopeia. Analyze the ratio of brand-name to generic drugs. Map controlled substance schedules across therapeutic categories.

#### Creative and Educational Projects

Build medication reference tools for nursing students or pharmacy technician exam prep. Create interactive drug class browsers for healthcare education.

#### Non-Profit and Public Health

Compile accessible drug information resources for underserved communities. Build medication guides in plain language powered by Drugs.com descriptions.

#### Developer Experimentation

Test NLP pipelines on pharmaceutical text. Build drug name entity recognition models. Experiment with structured health data for machine learning projects.

***

### 🤖 Ask an AI assistant about this scraper

Want to understand how to use this actor, what fields it returns, or how to integrate it into your project? Ask your AI assistant:

> "I'm using the ParseForge Drugs.com Medication Scraper on Apify. It scrapes drug information including name, genericName, brandNames, drugClass, description, usedFor, warningsSummary, sideEffectsSummary, availableForms, approvalStatus, pregnancyCategory, and csaSchedule fields. How can I use this data to build a drug interaction checker?"

***

### ❓ Frequently Asked Questions

#### 🤔 Is Drugs.com data free to access?

Yes - Drugs.com is a public website. This actor scrapes publicly available information, the same data visible to any visitor without logging in.

#### 📊 How many drugs can I scrape?

There are 24,000+ drug records on Drugs.com spread across A-Z. Free users are limited to 10 per run. Paid users can scrape up to 1,000,000 per run.

#### 🔄 How fresh is the data?

All data is scraped in real-time at the moment you run the actor. Drugs.com updates their content regularly - this actor always returns the current live version.

#### 💊 Does it work for both brand-name and generic drugs?

Yes. The actor handles both brand-name drugs (e.g. Abilify, Advil) and generic drugs (e.g. Aspirin, Ibuprofen). The `genericName` field always returns the chemical name.

#### 🔒 What does the CSA Schedule field mean?

The Controlled Substances Act (CSA) Schedule is the DEA's classification system for drugs with abuse potential. Schedule I = highest risk, Schedule V = lowest. Most drugs return "Not a controlled drug (N/A)".

#### 🤰 What does the Pregnancy Category field show?

The `pregnancyCategory` field shows the pregnancy and lactation risk classification from Drugs.com, typically "Risk data available" when FDA data exists for that medication.

#### 🏥 What is the `approvalStatus` field?

Indicates how the drug is available: "Prescription only" (Rx), "OTC" (over-the-counter), or "Rx and/or OTC" depending on the formulation and dose.

#### 📝 What does `usedFor` contain?

An array of medical conditions the drug is indicated for, extracted from Drugs.com's "Related treatment guides" section. Examples: \["Heart Attack", "Angina", "Pain"].

#### 🌐 Can I scrape specific drugs without browsing by letter?

Yes - use the `drugNames` input field with an array of drug names like `["aspirin", "metformin", "lisinopril"]`. This bypasses the letter-browse and fetches those specific pages directly.

#### ⚡ How fast is the actor?

In cloud runs, the actor processes approximately 5-10 drugs per 5 seconds. With `maxItems: 500`, expect a run time of around 5-10 minutes.

#### 🛡️ Does it handle Cloudflare protection?

Yes - the actor uses `got-scraping` with Chrome browser fingerprinting headers, which passes standard bot detection on Drugs.com without needing a headless browser.

#### 📁 What output formats are available?

JSON, CSV, Excel (xlsx), XML, and JSONL - all available for download from your Apify dataset after each run.

***

### 🔌 Integrate with any app

Connect your Drugs.com dataset to:

| Platform | Use |
|---|---|
| Google Sheets | Auto-populate drug reference sheets |
| Airtable | Build searchable drug databases |
| Notion | Create pharmaceutical reference wikis |
| Slack | Alert teams when new drug data is collected |
| Make (Integromat) | Multi-step automation with Drugs.com data |
| Zapier | Connect to 5,000+ apps |
| REST API | Integrate into custom applications |
| MongoDB | Store structured drug records |
| PostgreSQL | Power SQL-based drug queries |
| BigQuery | Large-scale pharmaceutical analytics |

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database - 75,000+ airports worldwide |
| [ParseForge ClinicalTrials Scraper](https://apify.com/parseforge) | Clinical trial data from ClinicalTrials.gov |
| [ParseForge FDA Drug Database](https://apify.com/parseforge) | FDA drug approval records and history |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more healthcare, finance, and data scrapers.

***

**Disclaimer:** This actor scrapes publicly available information from Drugs.com for informational purposes only. The scraped data is provided by Drugs.com and their data partners (Micromedex, Cerner Multum, ASHP). This actor is not affiliated with or endorsed by Drugs.com. Always consult a qualified healthcare provider before making medical decisions. Do not use scraped drug information as a substitute for professional medical advice.

# Actor input Schema

## `startLetter` (type: `string`):

Starting letter of drug names to scrape. Browse all medications that begin with this letter.

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

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

## `drugNames` (type: `array`):

Optional list of specific drug names to look up directly (e.g. \["aspirin", "ibuprofen"]). When provided, overrides Start Letter.

## Actor input object example

```json
{
  "startLetter": "a",
  "maxItems": 10
}
```

# 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 = {
    "startLetter": "a",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drugs.com Scraper | Medication Database",
        "description": "Extract drug data from Drugs.com including name, brand, generic equivalents, dosage, side effects, interactions, warnings, contraindications, and user reviews. Build pharma datasets, medical apps, drug interaction checkers, and healthcare research tools with comprehensive info.",
        "version": "0.1",
        "x-build-id": "9xEE40vqcvW7Tza2V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~drugs-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-drugs-com-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~drugs-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-drugs-com-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~drugs-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-drugs-com-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": {
                    "startLetter": {
                        "title": "Start Letter",
                        "enum": [
                            "a",
                            "b",
                            "c",
                            "d",
                            "e",
                            "f",
                            "g",
                            "h",
                            "i",
                            "j",
                            "k",
                            "l",
                            "m",
                            "n",
                            "o",
                            "p",
                            "q",
                            "r",
                            "s",
                            "t",
                            "u",
                            "v",
                            "w",
                            "x",
                            "y",
                            "z"
                        ],
                        "type": "string",
                        "description": "Starting letter of drug names to scrape. Browse all medications that begin with this letter.",
                        "default": "a"
                    },
                    "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"
                    },
                    "drugNames": {
                        "title": "Specific Drug Names",
                        "type": "array",
                        "description": "Optional list of specific drug names to look up directly (e.g. [\"aspirin\", \"ibuprofen\"]). When provided, overrides Start Letter.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
