# 🟣 FDA Purple Book — Biologics & Biosimilars Tracker (`nexgendata/fda-purple-book-biologics-biosimilars`) Actor

Search the FDA Purple Book: licensed biologics, biosimilars, and interchangeables with reference-product linkage and exclusivity-expiry dates that signal when biosimilar competition can begin. For biosimilar developers, pharma investors, and IP/regulatory teams.

- **URL**: https://apify.com/nexgendata/fda-purple-book-biologics-biosimilars.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## 🟣 FDA Purple Book — Biologics & Biosimilars Tracker

**The licensed-biologics and biosimilar database behind every biosimilar pipeline decision — reference-product linkage, exclusivity-expiry dates, and 351(k) competitive status, delivered as pay-per-record JSON for cents instead of a five-figure IQVIA, Cortellis, or Evaluate seat.**

The FDA Purple Book is the official register of every biological product licensed by the FDA under the Public Health Service Act — reference biologics (351(a)), biosimilars and interchangeables (351(k)), and the exclusivity windows that gate when biosimilar competition can legally begin. This actor pulls that register as structured records you can filter, join, and load straight into a model: proper (nonproprietary) name, proprietary (brand) name, applicant, license type, the reference product a biosimilar is licensed against, approval date, exclusivity-expiration date, and current marketing status.

For a biosimilar developer deciding which molecule to chase, an IP team mapping when a blockbuster biologic loses exclusivity, or a pharma investor sizing a biosimilar-erosion thesis, the single most valuable field in the entire dataset is the exclusivity-expiration date tied to a reference product. That one date tells you when the door opens. This actor lets you query it directly — "show me every reference biologic whose exclusivity expires before 2028" — instead of paying for an enterprise life-sciences platform to surface the same public FDA data behind a login.

### Why use this

The Purple Book itself is free to browse on the FDA website, but it is built for one-product-at-a-time lookups, not pipeline analysis. You cannot ask it "list every adalimumab biosimilar and the dates each was approved," you cannot sort the universe by exclusivity-expiry, and you certainly cannot pipe it into a screening model. The commercial platforms that *do* let you do that — IQVIA, Clarivate Cortellis, Evaluate Pharma — wrap the same public regulatory facts in a seat licence that runs from low five figures to well over six figures a year.

This actor gives you the structured, queryable layer without the licence. You pass a filter — a molecule, a brand, an applicant, a license type, or an exclusivity-expiry date window — and you get back clean JSON records with the reference-product linkage and dates already parsed. It runs pay-per-result: you pay for the records you actually pull, nothing else. There is no seat, no annual commitment, and no minimum.

Three things make it specifically useful rather than just cheap:

- **Reference-product linkage is first-class.** Pass a reference biologic (by proper or brand name) and the `referenceProduct` filter returns every 351(k) product licensed against it. That is the biosimilar-competition map for a molecule, on demand.
- **Exclusivity-expiry is a queryable range, not a buried cell.** The `exclusivityExpiringBefore` / `exclusivityExpiringAfter` window lets you isolate near-term biosimilar opportunities — the products whose protection lapses inside your investment or development horizon.
- **The output schema is stable and additive.** Load it into Snowflake, BigQuery, or your CRM once and refresh it on a schedule without re-mapping columns each time.

### What you get

Every record this actor returns is structured JSON populated from the FDA Purple Book wherever the source provides the field:

- `proprietaryName` — the proprietary (brand) name of the product (e.g. "Humira", "Hadlima")
- `properName` — the proper / nonproprietary name, i.e. the active substance (e.g. "adalimumab", "adalimumab-bwwd")
- `applicant` — the sponsoring company that holds the licence
- `licenseType` — 351(a) reference biologic, 351(k) Biosimilar, or 351(k) Interchangeable
- `referenceProduct` — for a biosimilar, the reference biologic it is licensed against
- `approvalDate` — the date the product was licensed by the FDA
- `exclusivityExpirationDate` — when the exclusivity period protecting the product expires (the gate for biosimilar entry)
- `marketingStatus` — the product's current marketing status

Because the schema is additive-only, you can build a pipeline on these eight fields and trust that a future run will not rename or drop them out from under your ETL.

### Use cases

- **Biosimilar opportunity screening.** Set `onlyBiosimilars` off, filter `licenseType` to 351(a), and apply `exclusivityExpiringBefore` to surface every reference biologic losing protection inside your development window — the canonical "what molecule should we develop next" question.
- **Reference-product competition mapping.** Pass `referenceProduct=adalimumab` (or a brand) to pull the complete roster of biosimilars and interchangeables already approved against a given originator, with each one's approval date and applicant — instant competitive-density read on a molecule.
- **Interchangeability tracking.** Filter `licenseType` to 351(k) Interchangeable to isolate the products that have cleared the higher FDA bar for pharmacy-level substitution, the status that most changes a biosimilar's commercial trajectory.
- **IP / patent-cliff calendars.** Use the `exclusivityExpiringAfter` / `exclusivityExpiringBefore` window to build a biologics exclusivity-cliff calendar for an IP, licensing, or litigation team.
- **Applicant / competitor portfolio audit.** Pass an `applicant` substring to enumerate every licensed biologic and biosimilar a given company holds — useful for M&A diligence, competitor monitoring, or partnership scouting.
- **Pharma investment theses.** Size a biosimilar-erosion or originator-defence thesis by pulling the reference product plus every biosimilar approved against it and the dates each entered — the raw inputs to a revenue-erosion model.
- **Regulatory affairs verification.** Confirm a product's exact license type, BLA, approval date, and current marketing status before a filing, a contract, or a due-diligence sign-off.
- **Market-access and pricing research.** Combine biosimilar count per reference product with marketing status to gauge competitive intensity entering payer negotiations.

### Sample output

A single record returned by the actor:

```json
{
  "proprietaryName": "Hadlima",
  "properName": "adalimumab-bwwd",
  "applicant": "Organon LLC",
  "licenseType": "351(k) Biosimilar",
  "referenceProduct": "Humira (adalimumab)",
  "approvalDate": "2019-07-23",
  "exclusivityExpirationDate": "2023-06-30",
  "marketingStatus": "Marketed"
}
````

A run filtered to `referenceProduct=adalimumab` returns one such record per biosimilar licensed against Humira, each carrying its own applicant, approval date, and marketing status — the full competitive basket for the molecule in one dataset.

### Input parameters

| Parameter | Label | Description |
|---|---|---|
| `properName` | Proper (nonproprietary) name | Active substance / nonproprietary name, contains match (e.g. `adalimumab`). |
| `proprietaryName` | Proprietary (brand) name | Brand name, contains match (e.g. `Humira`, `Hadlima`). |
| `applicant` | Applicant / company | Sponsoring company, contains match. |
| `blaNumber` | BLA number | Exact Biologics License Application number. |
| `referenceProduct` | Reference product | Find biosimilars of this reference biologic (matches reference proper / brand name). |
| `licenseType` | License type | 351(a) = reference biologic; 351(k) Biosimilar; 351(k) Interchangeable. |
| `onlyBiosimilars` | Only biosimilars / interchangeables | Return only 351(k) products (biosimilars and interchangeables). |
| `exclusivityExpiringAfter` | Exclusivity expiring after | Keep products whose exclusivity expires on/after this date (YYYY-MM-DD). |
| `exclusivityExpiringBefore` | Exclusivity expiring before | Keep products whose exclusivity expires on/before this date (YYYY-MM-DD). Useful for near-term biosimilar opportunities. |
| `maxResults` | Max results | Maximum number of product records to return. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/fda-purple-book-biologics-biosimilars").call(run_input={
    "referenceProduct": "adalimumab",
    "onlyBiosimilars": True,
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["proprietaryName"], item["applicant"], item["approvalDate"], item["exclusivityExpirationDate"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~fda-purple-book-biologics-biosimilars/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "licenseType": "351(a)",
    "exclusivityExpiringBefore": "2028-12-31",
    "maxResults": 200
  }'
```

Schedule it monthly via Apify's built-in scheduler to keep a fresh biosimilar-exclusivity calendar, and wire a webhook to Slack, Zapier, Make, or n8n so a new biosimilar approval against a molecule you track fires an alert the moment it lands in the dataset.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — **$0.10 per result record**, plus a negligible one-time actor-start charge per run. No subscription, no seat licence, no minimum.

Worked examples:

- Every biosimilar against one reference product (~10 records) → **~$1.00**
- A full near-term exclusivity-cliff scan of 200 reference biologics → **~$20.00**
- A one-off audit of an applicant's entire 40-product portfolio → **~$4.00**

You pay only for records pushed to the dataset. If a filter matches nothing, you pay nothing for results. Apify's free monthly tier covers most exploratory runs outright. Browse the full NexGenData catalog at https://apify.com/nexgendata?fpr=2ayu9b

### How this compares to IQVIA / Cortellis / Evaluate

| Source | Price | What you get |
|---|---|---|
| IQVIA biosimilar intelligence | Enterprise contract (high five / six figures) | Deep biosimilar analytics, forecasting, claims data — bundled, seat-locked |
| Clarivate Cortellis | ~$tens of thousands / seat / yr | Regulatory + competitive intelligence across the pipeline, seat licence |
| Evaluate Pharma | ~$tens of thousands / seat / yr | Consensus forecasts and biosimilar-erosion models, seat licence |
| FDA Purple Book (official site) | Free | One-lookup-at-a-time web UI; no bulk query, no API, no exclusivity-range filter |
| **NexGenData Purple Book Tracker** | **PPE $0.10 / record** | **Queryable, structured biologics + biosimilar register with reference-product linkage and exclusivity-expiry windows, as JSON** |

The honest framing: if you need consensus revenue forecasts, claims-level erosion curves, and a full regulatory-intelligence workspace, you still buy a Cortellis or Evaluate seat. But if your actual need is the structured, filterable *facts* — which biosimilars exist, against what reference product, approved when, with exclusivity expiring when — this actor delivers exactly that layer for a tiny fraction of the cost, and pipes it straight into your own model instead of trapping it behind someone's terminal.

### FAQ

**Q: Where does the data come from?**
A: The FDA Purple Book, the agency's official database of biological products licensed under the Public Health Service Act. The actor reads the public register and returns it as structured records.

**Q: What is the difference between 351(a) and 351(k)?**
A: 351(a) products are reference (originator) biologics licensed on their own full data package. 351(k) products are biosimilars and interchangeables licensed against an existing reference product. Use `licenseType` or `onlyBiosimilars` to isolate either group.

**Q: How do I find every biosimilar of a specific drug?**
A: Pass the molecule or brand to the `referenceProduct` filter. The actor returns every 351(k) product licensed against that reference biologic, each with its own approval date, applicant, and marketing status.

**Q: Can I find biologics losing exclusivity soon?**
A: Yes — that is what `exclusivityExpiringBefore` is for. Combine it with `licenseType=351(a)` to list reference biologics whose protection lapses before your chosen date, the leading indicator of an opening biosimilar opportunity.

**Q: Is exclusivity-expiration the same as patent expiry?**
A: No. This field reflects the FDA regulatory-exclusivity period recorded in the Purple Book, which is distinct from a product's patent estate. For patent-cliff analysis, pair this actor with patent data; treat exclusivity-expiry as the regulatory gate, not the full IP picture.

**Q: How current is it?**
A: Each run reads the live Purple Book, so results reflect the FDA's current published register at run time. Schedule a monthly refresh to keep a rolling exclusivity calendar.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added over time — they appear as new JSON keys, defaulting to `null` for older records — but existing fields are never renamed or removed without a major-version bump and an advance changelog note. Field semantics (date formats, license-type value sets) are never silently changed; if a change is unavoidable, a new field is added and the old one kept for at least 90 days. You can build production ETL on the eight documented fields and trust it to keep parsing.

### Compliance & legal

- The actor reads the **public, unauthenticated** FDA Purple Book — the same data any browser sees, published by the FDA specifically for public access.
- No login, credentials, or paywalled source is involved; nothing is collected or stored on your behalf beyond the records you request.
- The Purple Book is US-government regulatory data and is not subject to copyright, but you remain responsible for ensuring your downstream use complies with your jurisdiction's rules and any sector-specific obligations.
- Treat exclusivity and license data as informational, not legal advice — verify against the primary FDA record before relying on it for a regulatory filing or litigation decision.

### Related NexGenData actors

Part of NexGenData's pharma & regulatory intelligence lane — pair this actor with:

- [FDA Orange Book Drug Patents](https://apify.com/nexgendata/fda-orange-book-drug-patents?fpr=2ayu9b) — small-molecule patent & exclusivity linkage (the generics counterpart to the Purple Book)
- [FDA Drug Approvals](https://apify.com/nexgendata/fda-drug-approvals?fpr=2ayu9b) — new drug & biologic approval stream
- [FDA Drug Shortages Monitor](https://apify.com/nexgendata/fda-drug-shortages-monitor?fpr=2ayu9b) — active shortage and resolution tracking
- [FDA Recall Monitor](https://apify.com/nexgendata/fda-recall-monitor?fpr=2ayu9b) — drug & device recall feed
- [Clinical Trials Tracker](https://apify.com/nexgendata/clinical-trials-tracker?fpr=2ayu9b) — trial pipeline by molecule, sponsor, and phase
- [NIH RePORTER Grants Scraper](https://apify.com/nexgendata/nih-reporter-grants-scraper?fpr=2ayu9b) — federal biomedical research funding

Explore the full catalog of 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

# Actor input Schema

## `properName` (type: `string`):

Active substance / nonproprietary name, contains match (e.g. 'adalimumab').

## `proprietaryName` (type: `string`):

Brand name, contains match (e.g. 'Humira', 'Hadlima').

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

Sponsoring company, contains match.

## `blaNumber` (type: `string`):

Exact Biologics License Application number.

## `referenceProduct` (type: `string`):

Find biosimilars of this reference biologic (matches reference proper/brand name).

## `licenseType` (type: `array`):

351(a) = reference biologic; 351(k) Biosimilar; 351(k) Interchangeable.

## `onlyBiosimilars` (type: `boolean`):

Return only 351(k) products (biosimilars and interchangeables).

## `exclusivityExpiringAfter` (type: `string`):

Keep products whose exclusivity expires on/after this date (YYYY-MM-DD).

## `exclusivityExpiringBefore` (type: `string`):

Keep products whose exclusivity expires on/before this date (YYYY-MM-DD). Useful for near-term biosimilar opportunities.

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

Maximum number of product records to return.

## Actor input object example

```json
{
  "properName": "adalimumab",
  "onlyBiosimilars": false,
  "maxResults": 3000
}
```

# 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 = {
    "properName": "adalimumab"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/fda-purple-book-biologics-biosimilars").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 = { "properName": "adalimumab" }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/fda-purple-book-biologics-biosimilars").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 '{
  "properName": "adalimumab"
}' |
apify call nexgendata/fda-purple-book-biologics-biosimilars --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/fda-purple-book-biologics-biosimilars",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🟣 FDA Purple Book — Biologics & Biosimilars Tracker",
        "description": "Search the FDA Purple Book: licensed biologics, biosimilars, and interchangeables with reference-product linkage and exclusivity-expiry dates that signal when biosimilar competition can begin. For biosimilar developers, pharma investors, and IP/regulatory teams.",
        "version": "0.0",
        "x-build-id": "ZczgR2w2nRZsPcQOX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~fda-purple-book-biologics-biosimilars/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-fda-purple-book-biologics-biosimilars",
                "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/nexgendata~fda-purple-book-biologics-biosimilars/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-fda-purple-book-biologics-biosimilars",
                "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/nexgendata~fda-purple-book-biologics-biosimilars/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-fda-purple-book-biologics-biosimilars",
                "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": {
                    "properName": {
                        "title": "Proper (nonproprietary) name",
                        "type": "string",
                        "description": "Active substance / nonproprietary name, contains match (e.g. 'adalimumab')."
                    },
                    "proprietaryName": {
                        "title": "Proprietary (brand) name",
                        "type": "string",
                        "description": "Brand name, contains match (e.g. 'Humira', 'Hadlima')."
                    },
                    "applicant": {
                        "title": "Applicant / company",
                        "type": "string",
                        "description": "Sponsoring company, contains match."
                    },
                    "blaNumber": {
                        "title": "BLA number",
                        "type": "string",
                        "description": "Exact Biologics License Application number."
                    },
                    "referenceProduct": {
                        "title": "Reference product",
                        "type": "string",
                        "description": "Find biosimilars of this reference biologic (matches reference proper/brand name)."
                    },
                    "licenseType": {
                        "title": "License type",
                        "type": "array",
                        "description": "351(a) = reference biologic; 351(k) Biosimilar; 351(k) Interchangeable.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "351(a)",
                                "351(k) Biosimilar",
                                "351(k) Interchangeable"
                            ]
                        }
                    },
                    "onlyBiosimilars": {
                        "title": "Only biosimilars/interchangeables",
                        "type": "boolean",
                        "description": "Return only 351(k) products (biosimilars and interchangeables).",
                        "default": false
                    },
                    "exclusivityExpiringAfter": {
                        "title": "Exclusivity expiring after",
                        "type": "string",
                        "description": "Keep products whose exclusivity expires on/after this date (YYYY-MM-DD)."
                    },
                    "exclusivityExpiringBefore": {
                        "title": "Exclusivity expiring before",
                        "type": "string",
                        "description": "Keep products whose exclusivity expires on/before this date (YYYY-MM-DD). Useful for near-term biosimilar opportunities."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product records to return.",
                        "default": 3000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```