# RxList Scraper | Prescription Drug Information (`parseforge/rxlist-scraper`) Actor

Extract prescription drug data from RxList including indications, dosage, side effects, interactions, warnings, contraindications, and patient information. Build medical reference apps, pharma datasets, drug interaction checkers, and healthcare AI training corpora at scale.

- **URL**: https://apify.com/parseforge/rxlist-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)

## 💊 RxList Drug Information Scraper

> 🚀 **Export FDA drug data in seconds.** Scrape the complete RxList drug directory - **10,000+ FDA-reviewed drugs** with generic names, drug class, uses, side effects, dosage, warnings, interactions, and pregnancy information. No API key required.

> 🕒 **Last updated:** 2026-05-22 · **📊 15 fields** per record · **💊 10,000+ drugs** · **🔤 A-Z coverage** · **🏥 FDA-reviewed**

The RxList Drug Information Scraper extracts structured pharmaceutical data from RxList.com, one of the most trusted drug reference databases on the internet. Each record includes the drug's brand name, generic equivalent, drug class, clinical description, approved uses, side effects profile, dosage guidelines, safety warnings, drug interactions, pregnancy considerations, and manufacturer details - all sourced directly from FDA-reviewed drug monographs in real time.

RxList is part of the WebMD network and covers over 10,000 prescription and over-the-counter drugs across the full A-Z index. The database is used by physicians, pharmacists, patients, and researchers as a primary reference for drug prescribing information.

The scraper navigates the A-Z drug index (26 letter pages, 400-800 drugs each) and visits each individual drug page to extract the full monograph. You can scrape a single letter or the entire directory.

**Coverage at a glance:**
- 10,000+ drugs and drug products across the complete A-Z index
- 15 structured fields per drug record
- Covers generic drugs, brand-name drugs, combination products, and biologics
- Sources: FDA-reviewed drug monographs on RxList.com

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Pharmaceutical researchers | Build drug databases for research and analysis |
| Healthcare startups | Power drug reference apps and clinical decision tools |
| Health information platforms | Enrich content with authoritative drug data |
| Pharmacovigilance teams | Monitor drug safety profiles at scale |
| Medical educators | Build structured datasets for teaching and training |
| Data journalists | Investigate drug approvals, side effects, and warnings |
| AI/ML developers | Train models on structured pharmaceutical text |
| Regulatory consultants | Audit drug information completeness across products |

### 📋 What the RxList Scraper does

- Walks the complete A-Z drug index at rxlist.com (or a single letter on demand)
- Collects every drug URL listed under each letter
- Fetches each individual drug page and parses the full drug monograph
- Extracts 15 fields: brand name, generic name, drug class, description, uses, side effects, dosage, warnings, interactions, pregnancy info, manufacturer, and URL
- Respects `maxItems` to give you exactly the dataset size you need
- Exports to CSV, Excel, JSON, or XML from the Apify dataset tab

> 💡 **Why it matters:** Drug information is critical for patient safety, clinical research, and health app development. RxList provides FDA-reviewed monographs in a consistent format - but accessing them programmatically requires scraping. This actor does the heavy lifting so you get structured data, not raw HTML.

### 🎬 Full Demo

🚧 Coming soon - video walkthrough of the scraper in action

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `maxItems` | integer | Maximum number of drug records to collect. Free users: limited to 10. Paid users: up to 1,000,000. | 10 |
| `letter` | string (A-Z) | Scrape only drugs starting with this letter. Leave empty to scrape all 26 letters. | (all letters) |

**Example 1 - Scrape 5 drugs starting with A:**
```json
{
    "letter": "A",
    "maxItems": 5
}
````

**Example 2 - Scrape all drugs starting with Z (up to 1000):**

```json
{
    "letter": "Z",
    "maxItems": 1000
}
```

> ⚠️ **Good to Know:** Each letter index contains 400-800 drug entries. To scrape the complete database (10,000+ drugs), leave the `letter` field empty and set `maxItems` to 1,000,000. The scraper will automatically walk all 26 letters in alphabetical order.

### 📊 Output

Each drug record contains 15 structured fields:

| Field | Type | Description |
|---|---|---|
| 💊 `drugName` | string | Brand name as listed on RxList |
| 🔬 `genericName` | string | Generic (chemical) name of the drug |
| 🏷 `brandNames` | string | All brand names for this generic drug |
| 📂 `drugClass` | string | Pharmacological class (e.g., "Corticosteroids") |
| 📄 `description` | string | Clinical overview of the drug and its mechanism |
| 🩺 `usedFor` | string | Approved indications and therapeutic uses |
| ⚠️ `sideEffects` | string | Known adverse effects (common and serious) |
| 💉 `dosage` | string | Recommended dosage and administration guidelines |
| 🚨 `warnings` | string | Boxed warnings and safety precautions |
| 🔀 `interactions` | string | Notable drug-drug interactions |
| 🤰 `pregnancy` | string | Pregnancy and breastfeeding safety information |
| 🏭 `manufacturer` | string | Drug manufacturer (when listed on the page) |
| 🔗 `rxListUrl` | string | Direct link to the RxList drug monograph |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |
| ❌ `error` | string | Error message if the drug page failed to parse (null otherwise) |

**Sample record:**

```json
{
    "drugName": "Ziagen",
    "genericName": "abacavir sulfate",
    "brandNames": "Ziagen",
    "drugClass": "HIV, NNRTIs, Antiretroviral Agents",
    "description": "Ziagen (abacavir sulfate) is an antiviral medication used to treat HIV, which causes the acquired immunodeficiency syndrome (AIDS). Ziagen is not a cure for HIV or AIDS.",
    "usedFor": "ZIAGEN tablets and oral solution, in combination with other antiretroviral agents, are indicated for the treatment of human immunodeficiency virus (HIV-1) infection.",
    "sideEffects": "Common side effects of Ziagen include: trouble sleeping, loss of appetite, strange dreams, headache, ear pain, cold symptoms (stuffy nose, sneezing, sinus pain), or changes in the shape or location of body fat...",
    "dosage": "The recommended oral dose of Ziagen for adults is 600 mg daily, administered as either 300 mg twice daily or 600 mg once daily, in combination with other antiretroviral agents.",
    "warnings": "Included as part of the \"PRECAUTIONS\" Section",
    "interactions": null,
    "pregnancy": "During pregnancy, Ziagen should be used only when prescribed. HIV medicines are usually given to pregnant women with HIV...",
    "manufacturer": "GlaxoSmithKline Research Triangle Park, NC 27709",
    "rxListUrl": "https://www.rxlist.com/ziagen-drug.htm",
    "scrapedAt": "2026-05-21T21:43:57.000Z",
    "error": null
}
```

**Note on null fields:** `manufacturer` is null for drugs where RxList does not list this information on the page. `interactions` may be null for some drugs if the page structure omits that section.

### ✨ Why choose this Actor

| Feature | ParseForge RxList Scraper |
|---|---|
| 🏥 **FDA-reviewed data** | All content sourced from official FDA drug monographs via RxList |
| 🔤 **Full A-Z coverage** | 26 letter indexes, 10,000+ drugs in a single run |
| 📊 **15 structured fields** | Description, uses, side effects, dosage, warnings, interactions, pregnancy info |
| ⚡ **Fast execution** | Processes 5 drugs in under 3 seconds on Apify cloud |
| 💾 **Multiple export formats** | CSV, Excel, JSON, XML out of the box |
| 🔒 **No authentication required** | RxList is publicly accessible - no login or API key needed |
| 🔧 **Letter filter** | Target a specific letter for targeted dataset builds |
| 🆓 **Free tier available** | 10 drug records free - no credit card required |

### 📈 How it compares to alternatives

| Approach | ParseForge RxList Scraper | Manual copy-paste | Drug APIs (RxNorm, etc.) |
|---|---|---|---|
| **Setup time** | 30 seconds | Hours to days | Hours (API key, rate limits) |
| **Structured output** | Yes - 15 fields | No - manual formatting | Varies by API |
| **Side effects / warnings** | Yes | Manual | Rarely included |
| **Export formats** | CSV, JSON, Excel, XML | Manual | API-only |
| **Scale** | 10,000+ drugs | ~50 drugs/day manually | Limited by rate limits |
| **Cost** | Pay-per-result or free tier | Staff time | API subscription fees |

### 🚀 How to use

1. **[Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp)** - includes $5 in free credit
2. Open the **RxList Drug Information Scraper** on the Apify Store
3. Click **Try for free**
4. Set your input: choose a `letter` (A-Z) or leave blank for all, and set `maxItems`
5. Click **Start** and wait for results (typically under 10 seconds for 5 items)
6. Download your dataset as CSV, Excel, JSON, or XML from the **Dataset** tab

### 💼 Business use cases

#### Drug reference applications

Healthcare apps and patient portals need structured, up-to-date drug information. The RxList scraper provides 15 fields per drug - including clinical descriptions, dosage, and warnings - ready to import into your database without manual data entry.

#### Pharmacovigilance and safety monitoring

Pharmaceutical companies and regulators track adverse event profiles across drug classes. Export complete side effects and warnings data for hundreds of drugs at once. Cross-reference with your internal safety database to identify gaps or discrepancies in reported adverse events.

#### Clinical decision support systems

Medical software needs accurate drug information to power dosing calculators, interaction checkers, and prescribing assistants. The structured output from this scraper feeds directly into drug knowledge bases with fields for generic name, drug class, interactions, and pregnancy safety.

#### Market research and competitive intelligence

Healthcare market analysts track drug portfolios, therapeutic classes, and manufacturer relationships. The `drugClass` and `manufacturer` fields enable competitive landscape mapping across therapeutic areas. Identify which drug classes are densest, which manufacturers have the broadest portfolios, and track brand-to-generic relationships.

### 🔌 Automating RxList Scraper

Connect the RxList Drug Information Scraper to your workflow tools:

- **Make (Integromat)**: Trigger a scrape run on a schedule and send new drug records to Google Sheets or Airtable
- **Zapier**: Connect to your CRM or database when new drug data is collected
- **Slack notifications**: Get notified when a scrape completes via the Apify-Slack integration
- **Google Sheets**: Export directly to a spreadsheet for team collaboration
- **Webhooks**: POST results to your own API endpoint when the run finishes

All integrations are available from the **Integrations** tab on the actor page.

### 🌟 Beyond business use cases

#### Academic research

Pharmacology researchers can build structured datasets of drug properties, side effect profiles, and drug classes for statistical analysis and literature review support.

#### Patient advocacy and health literacy

Non-profits building patient education resources can use this scraper to populate drug information databases that help patients understand their medications, risks, and alternatives.

#### AI training datasets

Machine learning teams building medical NLP models need large, structured corpora of drug-related text. The description, usedFor, sideEffects, and warnings fields provide rich clinical language at scale.

#### Open data projects

Developers building open-source drug reference tools can bootstrap their database with this scraper rather than manually curating data from individual drug pages.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant (like Claude or ChatGPT) questions like:

- "How do I use the Apify RxList scraper to get all drugs in class X?"
- "What fields does the RxList Drug Information Scraper return?"
- "How do I filter the output to find drugs with specific warnings?"
- "Can you write a Python script to process the JSON output from this scraper?"

The structured JSON output from this actor is easy for AI models to parse and analyze.

### ❓ Frequently Asked Questions

#### ❓ Is RxList data free to use?

RxList is publicly accessible. The data is sourced from FDA drug monographs. Check RxList's terms of service for your specific use case, particularly for commercial applications.

#### ❓ How many drugs does RxList have?

The A-Z index contains approximately 10,000+ drug entries. Letter A alone has 763 entries.

#### ❓ How long does a full scrape take?

A full scrape of all 26 letters (10,000+ drugs) takes approximately 2-4 hours on Apify's standard infrastructure at default concurrency.

#### ❓ Why is the manufacturer field null for some drugs?

Not all drug pages on RxList list a manufacturer. This is a data availability issue on the source, not a parsing bug. The field is populated when present.

#### ❓ Why is the interactions field null for some drugs?

Some drugs on RxList do not include a dedicated drug interactions section in their page HTML. This is source-dependent.

#### ❓ Can I scrape just one letter?

Yes. Set the `letter` input to any letter A-Z to restrict scraping to drugs starting with that letter.

#### ❓ Can I scrape all drugs in a specific drug class?

Not directly via input filter - the scraper collects all drugs and includes `drugClass` in the output. Filter by `drugClass` in your downstream processing (e.g., in Excel or Pandas).

#### ❓ Does this work with Apify proxy?

The scraper uses direct HTTP fetch without proxy. RxList is publicly accessible and does not block standard requests. If you encounter blocking, contact ParseForge.

#### ❓ How do I get more than 10 items as a free user?

Free accounts are limited to 10 items per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to access up to 1,000,000 items per run.

#### ❓ Is the data real-time?

Yes. The scraper fetches live pages from rxlist.com at run time. No cached or pre-stored data is returned.

#### ❓ What export formats are supported?

CSV, JSON, Excel (XLSX), and XML - all available from the Dataset tab after a run completes.

#### ❓ Can I integrate this with my database automatically?

Yes. Use the Apify API or Make/Zapier integration to push results to your database, spreadsheet, or data warehouse automatically after each run.

### 🔌 Integrate with any app

The RxList Drug Information Scraper integrates with your stack via the Apify platform:

**Databases:** PostgreSQL, MySQL, MongoDB, Airtable, Notion\
**Spreadsheets:** Google Sheets, Excel Online, Smartsheet\
**Data warehouses:** BigQuery, Snowflake, Redshift\
**Workflow tools:** Make, Zapier, n8n, Pipedream\
**Cloud storage:** Amazon S3, Google Cloud Storage, Azure Blob\
**BI tools:** Tableau, Power BI, Looker, Metabase\
**CRMs:** HubSpot, Salesforce (via Make/Zapier)\
**APIs:** REST webhooks to your own endpoints

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database - 85,000+ airports with ICAO, IATA, coordinates, type |
| [FDA Drug Adverse Events](https://apify.com/parseforge) | Complement drug info with real-world adverse event reports |
| [PubMed Research Scraper](https://apify.com/parseforge) | Extract medical literature for drug research and meta-analysis |

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

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** Independent tool, not affiliated with RxList, WebMD, or any pharmaceutical manufacturer. Only publicly available data collected. Drug information is for informational and research purposes only and is intended to supplement, not replace, professional medical advice. Always consult a qualified healthcare provider before making medical decisions. Use of this tool is subject to Apify's [Terms of Service](https://apify.com/terms-of-use) and RxList's terms of use.

# Actor input Schema

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

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

## `letter` (type: `string`):

Scrape only drugs starting with this letter (A-Z). Leave empty to scrape all letters.

## Actor input object example

```json
{
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rxlist-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rxlist-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/rxlist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RxList Scraper | Prescription Drug Information",
        "description": "Extract prescription drug data from RxList including indications, dosage, side effects, interactions, warnings, contraindications, and patient information. Build medical reference apps, pharma datasets, drug interaction checkers, and healthcare AI training corpora at scale.",
        "version": "0.1",
        "x-build-id": "PptFeORmsr3Y23zNl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rxlist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rxlist-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~rxlist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rxlist-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~rxlist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rxlist-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "letter": {
                        "title": "Letter Filter",
                        "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": "Scrape only drugs starting with this letter (A-Z). Leave empty to scrape all letters."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
