# Open Targets Platform Scraper (`parseforge/open-targets-platform-scraper`) Actor

Export drug, target, and disease intelligence from the Open Targets Platform. Pull 63,000+ targets, 20,000+ diseases, and 14,000+ drugs with association scores, tractability, mechanisms of action, clinical phase, and cross-references for drug discovery research.

- **URL**: https://apify.com/parseforge/open-targets-platform-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 result items

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)

## 🧬 Open Targets Platform Scraper

> 🚀 **Export drug, target, and disease intelligence in seconds.** Pull **63,000+ targets, 20,000+ diseases, and 14,000+ drugs** from the Open Targets Platform with evidence scores, tractability, mechanisms of action, and clinical phase. No registration, no manual extraction.

> 🕒 **Last updated:** 2026-05-20 · **📊 18 fields** per record · **🧬 63k+ targets** · **🦠 20k+ diseases** · **💊 14k+ drugs**

The **Open Targets Platform Scraper** exports drug discovery intelligence from the Open Targets Platform and returns up to **18 fields per record**, including identifiers, synonyms, descriptions, tractability assessments, target-disease associations, mechanisms of action, and clinical-trial indications. The underlying dataset is the reference open knowledge graph for therapeutic target identification, jointly built by EMBL-EBI, GSK, Sanofi, Bristol Myers Squibb, and other contributors.

Coverage spans **63,000+ targets (Ensembl IDs)**, **20,000+ diseases (EFO/MONDO)**, and **14,000+ drugs (ChEMBL)** with association scoring, druggability tiers, ubiquitination signals, pathway memberships, and disease-trait phenotype maps.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Pharma R&D teams, bioinformatics groups, biotech analysts, academic researchers, drug-repurposing startups, clinical-trial intelligence | Target prioritization, disease-target evidence reports, drug-repurposing scans, tractability snapshots, mechanism-of-action lookups, indication exploration |

---

### 📋 What the Open Targets Platform Scraper does

Three entity-specific workflows in a single run:

- 🧬 **Targets.** Pull gene-level records with approved symbol, biotype, synonyms, protein IDs, tractability across small-molecule / antibody / PROTAC / oligo modalities, pathway memberships, and the top associated diseases with evidence scores.
- 🦠 **Diseases.** Pull EFO/MONDO records with descriptions, synonyms, therapeutic areas, cross-references, ancestors/descendants, and the top associated targets.
- 💊 **Drugs.** Pull ChEMBL drug records with type, maximum clinical phase, approval status, withdrawals, trade names, mechanisms of action, and indication lists.

Each record includes a direct link back to the entity's page on `platform.opentargets.org` for spot-checking.

> 💡 **Why it matters:** drug discovery teams spend significant time stitching together target-disease evidence from disparate genetic, expression, and clinical sources. Open Targets is the canonical pre-stitched graph. This Actor flattens the relevant subset into a CSV/JSON snapshot you can drop into a notebook, dashboard, or LLM workflow.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>entityType</code></td><td>string</td><td><code>"target"</code></td><td>One of <code>target</code>, <code>disease</code>, or <code>drug</code>.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Free-text search. Examples: <code>BRAF</code>, <code>melanoma</code>, <code>pembrolizumab</code>.</td></tr>
<tr><td><code>targetIds</code></td><td>string[]</td><td><code>[]</code></td><td>Ensembl gene IDs (used when <code>entityType</code> is <code>target</code>).</td></tr>
<tr><td><code>diseaseIds</code></td><td>string[]</td><td><code>[]</code></td><td>EFO or MONDO IDs (used when <code>entityType</code> is <code>disease</code>).</td></tr>
<tr><td><code>drugIds</code></td><td>string[]</td><td><code>[]</code></td><td>ChEMBL IDs (used when <code>entityType</code> is <code>drug</code>).</td></tr>
</tbody>
</table>

**Example: top 25 search hits for "BRAF" as targets.**

```json
{
    "maxItems": 25,
    "entityType": "target",
    "searchQuery": "BRAF"
}
````

**Example: enrich a list of known drugs.**

```json
{
    "maxItems": 5,
    "entityType": "drug",
    "drugIds": ["CHEMBL1201585", "CHEMBL1201218", "CHEMBL2108524"]
}
```

> ⚠️ **Good to Know:** when a list of IDs is provided, the scraper skips the search step and pulls those entities directly. When the list is empty, the search query is used. Both modes coexist so you can build a targeted ID-batch run or an exploratory search run from the same input form.

***

### 📊 Output

Each record contains up to **18 fields** depending on entity type. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema (target)

| Field | Type | Example |
|---|---|---|
| 🧬 `entityType` | string | `"target"` |
| 🆔 `id` | string | `"ENSG00000157764"` |
| 🔤 `approvedSymbol` | string | `"BRAF"` |
| 📛 `approvedName` | string | `"B-Raf proto-oncogene, serine/threonine kinase"` |
| 🧪 `biotype` | string | `"protein_coding"` |
| 📜 `description` | string | null | Protein function summary |
| 🔁 `synonyms` | string\[] | null | Symbol synonyms |
| 🧫 `proteinIds` | object\[] | null | UniProt and Ensembl protein IDs |
| 🔗 `crossReferences` | object\[] | null | DB x-refs |
| 🎯 `tractability` | object\[] | null | Modality x druggability matrix |
| 📍 `subcellularLocations` | object\[] | null | Cell compartment evidence |
| 🛣️ `pathways` | object\[] | null | Reactome pathway memberships |
| 🧬 `geneticConstraint` | object\[] | null | gnomAD constraint scores |
| 🧪 `targetClass` | object\[] | null | ChEMBL target-class taxonomy |
| 🦠 `associatedDiseases` | object | null | Top disease evidence rows with scores |
| 🔗 `sourceUrl` | string | Platform page |
| 🕒 `scrapedAt` | ISO 8601 | Collection timestamp |

#### 📦 Sample records

<details>
<summary><strong>🧬 Target: BRAF (B-Raf proto-oncogene)</strong></summary>

```json
{
    "entityType": "target",
    "id": "ENSG00000157764",
    "approvedSymbol": "BRAF",
    "approvedName": "B-Raf proto-oncogene, serine/threonine kinase",
    "biotype": "protein_coding",
    "description": "Protein kinase involved in the transduction of mitogenic signals from the cell membrane to the nucleus...",
    "tractability": [{"label": "Approved Drug", "modality": "SM", "value": true}],
    "associatedDiseases": {"count": 1559, "rows": [{"score": 0.876, "disease": {"id": "MONDO_0015280", "name": "cardiofaciocutaneous syndrome"}}]},
    "sourceUrl": "https://platform.opentargets.org/target/ENSG00000157764"
}
```

</details>

<details>
<summary><strong>🦠 Disease: melanoma (EFO_0000756)</strong></summary>

```json
{
    "entityType": "disease",
    "id": "EFO_0000756",
    "name": "melanoma",
    "description": "A malignant, usually aggressive tumor composed of atypical, neoplastic melanocytes...",
    "therapeuticAreas": [{"id": "MONDO_0024458", "name": "disease of cellular proliferation"}],
    "associatedTargets": {"count": 800, "rows": [{"score": 0.81, "target": {"id": "ENSG00000157764", "approvedSymbol": "BRAF"}}]},
    "sourceUrl": "https://platform.opentargets.org/disease/EFO_0000756"
}
```

</details>

<details>
<summary><strong>💊 Drug: TRASTUZUMAB (CHEMBL1201585)</strong></summary>

```json
{
    "entityType": "drug",
    "id": "CHEMBL1201585",
    "name": "TRASTUZUMAB",
    "drugType": "Antibody",
    "maximumClinicalStage": 4,
    "isApproved": true,
    "yearOfFirstApproval": 1998,
    "tradeNames": ["Herceptin"],
    "mechanismsOfAction": [{"mechanismOfAction": "ERBB2 inhibitor", "targetName": "Receptor tyrosine-protein kinase erbB-2", "actionType": "INHIBITOR"}],
    "sourceUrl": "https://platform.opentargets.org/drug/CHEMBL1201585"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🧬 | **Full biomedical graph.** 63k+ targets, 20k+ diseases, 14k+ drugs in a single Actor with consistent fields. |
| 🎯 | **Multi-modality tractability.** Small molecule, antibody, PROTAC, oligonucleotide, and other modality classes per target. |
| 📊 | **Association scores.** Top-N disease-target evidence with scores baked into the disease and target records. |
| 💊 | **Clinical-phase data.** Drug records include maximum clinical phase, approval status, withdrawal flags, and indications. |
| ⚡ | **Fast.** 25 entities in under 30 seconds, hundreds in a few minutes. |
| 🔁 | **Always fresh.** Every run pulls the latest Open Targets release through the official graph. |
| 🚫 | **No authentication.** Open scientific data. No login or token required. |

> 📊 Open Targets is the consensus reference graph for target identification, used by major pharma R\&D teams worldwide.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Open Targets Platform Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **63k targets · 20k diseases · 14k drugs** | **Live per run** | search, ID list, entity type | ⚡ 2 min |
| Manual portal navigation | Free | Per-entity | Manual | None | 🐢 Tedious |
| Direct custom queries | Engineering time | Full | Live | Custom | 🛠️ Days |
| Commercial biomedical databases | $$$$/year | Variable | Variable | Many | ⏳ Long contract |

Pick this Actor when you want a clean, filtered slice of Open Targets without writing custom queries, handling pagination, or maintaining schema knowledge.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Open Targets Platform Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick an entity type, then either supply a list of IDs or a free-text search.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 💊 Pharma R\&D and target ID

- Score and prioritize target candidates by association evidence
- Build a tractability matrix across SM, antibody, PROTAC modalities
- Compare disease overlap across a panel of candidates
- Power weekly target-deck refreshes for portfolio reviews

</td>
<td width="50%" valign="top">

#### 🧪 Drug repurposing

- Enumerate indications and trial phases per drug
- Find shared mechanisms across approved drugs
- Map drugs to alternate diseases through target overlap
- Seed retrospective evidence packages for repositioning

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Biotech analysts and BD

- Pull due-diligence snapshots on acquisition targets' assets
- Generate target/disease landscape reports for clients
- Track competitive drug pipelines by indication
- Build investor decks with sourced evidence scores

</td>
<td width="50%" valign="top">

#### 🧬 Academic bioinformatics

- Reproducible target/disease enrichment analyses
- Course datasets for translational informatics modules
- Hypothesis-generation scans across published evidence
- Curated cohorts for bench-side validation studies

</td>
</tr>
</table>

***

### 🔌 Automating Open Targets Platform Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Monthly refreshes keep downstream analytics aligned with new Open Targets releases.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Translational informatics coursework with reproducible pulls
- Systematic reviews of target-disease evidence
- Reproducible dataset snapshots for cited bioinformatics papers
- Open-data exercises around drug discovery and rare diseases

</td>
<td width="50%">

#### 🎨 Personal and creative

- Bioscience side projects and visualizations
- Personal target-disease atlas dashboards
- Educational explainers and biotech newsletters
- Hobbyist exploration of human genetics and disease

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Rare-disease patient organizations cataloging therapies
- Open-science publishing with cited evidence rows
- Drug-access transparency around indications and approvals
- Hackathons for disease research and biotech tooling

</td>
<td width="50%">

#### 🧪 Experimentation

- Train biomedical NER and entity linking models
- Prompt engineering for LLM-driven literature triage
- Agent pipelines that look up tractability and pipelines
- Validate retrieval-augmented biomedical search

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Open%20Targets%20Platform%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Open%20Targets%20Platform%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Open%20Targets%20Platform%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Open%20Targets%20Platform%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick an entity type and either drop in a list of identifiers or run a free-text search. The Actor queries the Open Targets graph and returns one structured record per entity, including association rows and tractability matrices.

#### 📏 How accurate is the data?

The records mirror the latest Open Targets release. Evidence scores and clinical phases are computed by the Open Targets pipeline from curated sources (ChEMBL, OpenFDA, ClinVar, Reactome, and many more). For clinical decisions, validate against primary sources.

#### 🔁 How often is the dataset refreshed?

Open Targets ships full data releases on a regular cadence. Every run of this Actor pulls live from the graph, so your dataset reflects the latest published release at run time.

#### 🧬 Which identifier systems are supported?

Ensembl gene IDs for targets, EFO and MONDO for diseases, and ChEMBL for drugs. Cross-references in the output map to UniProt, dbSNP, RefSeq, DrugBank, and other systems.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) and keep a downstream database in sync with new Open Targets releases.

#### ⚖️ Is this data legal to use?

Open Targets data is published under CC0 with attribution. Underlying source data may carry separate licenses; review the Open Targets documentation for your specific use case.

#### 💼 Can I use this data commercially?

Yes. Open Targets data is free for academic and commercial use. The CC0 license places it in the public domain.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling and higher concurrency.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. Single-entity failures are skipped with a warning and the run continues. Partial datasets are preserved.

#### 🧪 What if I need full evidence trails?

This Actor returns the top-N association rows per target or disease. For deeper evidence and provenance, query individual entity pages on `platform.opentargets.org` or request a companion scraper through the contact form.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Open Targets Platform Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe biomedical data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push refreshed biomedical evidence into your product backend or notebook environment.

***

### 🔗 Recommended Actors

- [**🧪 ClinicalTrials.gov Scraper**](https://apify.com/parseforge/clinicaltrials-gov-scraper) - Worldwide clinical-trial registry
- [**📐 arXiv Preprint Scraper**](https://apify.com/parseforge/arxiv-scraper) - Open-access research papers
- [**🔬 Figshare Scraper**](https://apify.com/parseforge/figshare-scraper) - Open research artifacts
- [**🧬 GBIF Biodiversity Scraper**](https://apify.com/parseforge/gbif-biodiversity-scraper) - Global biodiversity occurrence records

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

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

# Actor input Schema

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

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

## `entityType` (type: `string`):

Which Open Targets entity to scrape.

## `searchQuery` (type: `string`):

Free-text search across the selected entity type. Examples: 'BRAF', 'melanoma', 'pembrolizumab'.

## `targetIds` (type: `array`):

Ensembl gene IDs (e.g. ENSG00000157764). Used when entityType is 'target'.

## `diseaseIds` (type: `array`):

EFO or MONDO identifiers (e.g. EFO\_0000756). Used when entityType is 'disease'.

## `drugIds` (type: `array`):

ChEMBL drug identifiers (e.g. CHEMBL1201585). Used when entityType is 'drug'.

## Actor input object example

```json
{
  "maxItems": 10,
  "entityType": "target"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "entityType": "target"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/open-targets-platform-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,
    "entityType": "target",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/open-targets-platform-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,
  "entityType": "target"
}' |
apify call parseforge/open-targets-platform-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Targets Platform Scraper",
        "description": "Export drug, target, and disease intelligence from the Open Targets Platform. Pull 63,000+ targets, 20,000+ diseases, and 14,000+ drugs with association scores, tractability, mechanisms of action, clinical phase, and cross-references for drug discovery research.",
        "version": "1.0",
        "x-build-id": "VgR3DYlJ9CUt8Myi8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~open-targets-platform-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-open-targets-platform-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~open-targets-platform-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-open-targets-platform-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~open-targets-platform-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-open-targets-platform-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"
                    },
                    "entityType": {
                        "title": "Entity Type",
                        "enum": [
                            "target",
                            "disease",
                            "drug"
                        ],
                        "type": "string",
                        "description": "Which Open Targets entity to scrape."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text search across the selected entity type. Examples: 'BRAF', 'melanoma', 'pembrolizumab'."
                    },
                    "targetIds": {
                        "title": "Target IDs (Ensembl)",
                        "type": "array",
                        "description": "Ensembl gene IDs (e.g. ENSG00000157764). Used when entityType is 'target'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "diseaseIds": {
                        "title": "Disease IDs (EFO/MONDO)",
                        "type": "array",
                        "description": "EFO or MONDO identifiers (e.g. EFO_0000756). Used when entityType is 'disease'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "drugIds": {
                        "title": "Drug IDs (ChEMBL)",
                        "type": "array",
                        "description": "ChEMBL drug identifiers (e.g. CHEMBL1201585). Used when entityType is 'drug'.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
