# ChEMBL Targets Scraper (`parseforge/chembl-targets-scraper`) Actor

Query the ChEMBL target catalog by ID, keyword, organism, or target type. Records include target ChEMBL ID, preferred name, organism, target type, gene symbol, tax ID, components with accession and description, and cross references. Useful for drug discovery research and target review.

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

## Pricing

from $7.50 / 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)

## 🧬 ChEMBL Targets Scraper

> 🚀 **Export ChEMBL drug-target records in seconds. Preferred name, organism, target type, components, gene symbol, and tax ID.**

> 🕒 **Last updated:** 2026-06-05 · **📊 11 fields** per record · 15,000+ drug targets · EBI ChEMBL public API

The ChEMBL Targets Scraper turns the public `ebi.ac.uk/chembl/api/data/target` endpoint into a structured dataset. It runs a list query, a free-text search, or an exact ChEMBL ID lookup, then flattens each target's components and gene-symbol synonyms into top-level fields.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 💊 Drug discovery teams | Build target shortlists for screening |
| 🧪 Bioinformaticians | Mirror ChEMBL targets into a warehouse |
| 📊 Computational chemists | Map targets to assays |
| 🛡️ Pharma BD | Cross-reference targets with patents |
| 👩‍🔬 Academic researchers | Snapshot the human target space |
| 👩‍💻 Developers | Drive a target browser UI |

### 📋 What the ChEMBL Targets Scraper does

- Calls the public `/data/target` endpoint with the filters you provide.
- Supports list, search, and exact-ID modes.
- Flattens the `target_components` array and pulls the GENE_SYMBOL synonym into `geneSymbol`.
- Filters by organism and target type.
- Surfaces upstream errors as a single diagnostic record.
- Exports to every Apify dataset format.

> 💡 **Why it matters:** ChEMBL's REST endpoint is rich but deeply nested. This actor lifts the most useful fields to the top so they drop straight into pandas or BigQuery.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free 10. Paid up to 1,000,000.</td></tr>
<tr><td><code>targetChemblId</code></td><td>string</td><td>No</td><td>Exact lookup such as `CHEMBL203`.</td></tr>
<tr><td><code>search</code></td><td>string</td><td>No</td><td>Free-text search.</td></tr>
<tr><td><code>organism</code></td><td>string</td><td>No</td><td>Exact organism filter.</td></tr>
<tr><td><code>targetType</code></td><td>enum</td><td>No</td><td>ChEMBL target type.</td></tr>
</table>

**Example 1. Search EGFR family.**
```json
{ "search": "EGFR", "organism": "Homo sapiens", "maxItems": 25 }
````

**Example 2. Exact target lookup.**

```json
{ "targetChemblId": "CHEMBL203" }
```

> ⚠️ **Good to Know:** ChEMBL paginates 200 records per page. The actor handles it automatically.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🆔 `targetChemblId` | string | ChEMBL target id. |
| 📛 `prefName` | string | Preferred name. |
| 🧬 `organism` | string | Source organism. |
| 🎯 `targetType` | string | Target type. |
| 🧫 `geneSymbol` | string | Gene symbol synonym. |
| 🔢 `taxId` | number | NCBI tax id. |
| 🚩 `speciesGroupFlag` | boolean | Species group flag. |
| 🧩 `components` | array | Flattened components with accessions. |
| 🔗 `crossReferences` | array | External cross-refs. |
| 🕒 `scrapedAt` | string | When this row was fetched. |
| ❌ `error` | string | Set on upstream error. |

```json
{
  "targetChemblId": "CHEMBL203",
  "prefName": "Epidermal growth factor receptor erbB1",
  "organism": "Homo sapiens",
  "targetType": "SINGLE PROTEIN",
  "geneSymbol": "EGFR",
  "taxId": 9606,
  "scrapedAt": "2026-06-05T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🆓 | Public EBI ChEMBL endpoint, no key required. |
| 🧬 | Flattens components and gene-symbol synonym to top level. |
| 🔎 | Search, list, or exact-ID modes. |
| 🛟 | Clean diagnostic records on errors. |
| 💾 | Push to dataset for instant export. |

### 📈 How it compares to alternatives

| Approach | Setup | Component flatten | Auto export |
|---|---|---|---|
| `chembl_webresource_client` Python | install + script | manual | manual |
| Raw fetch on the REST endpoint | 30 min + | manual | manual |
| **This Actor** | 5 sec | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Provide an ID, search, or list filters.
3. Click **Start** and download the dataset.

### 💼 Business use cases

**💊 Target triage.** Snapshot every human single-protein target related to a pathway.

**🧪 Assay planning.** Pair with the ChEMBL Assays Scraper for a full target-to-assay matrix.

**🛡️ Competitive landscape.** Cross-reference targets with patent or trial datasets.

**📊 Pipeline analytics.** Track new ChEMBL releases.

### 🔌 Automating ChEMBL Targets Scraper

- **Make and Zapier** trigger this actor on a schedule.
- **Cron** keeps your mirror fresh.
- **Webhooks** notify on completion.
- **Pipe to BigQuery, Snowflake, or Postgres** with native integrations.

### 🌟 Beyond business use cases

**🎓 Education.** Teach drug-discovery with live data.

**🧪 Personal research.** Explore the human target space.

**🤝 Non-profit and open data.** Publish a target dashboard.

**🧰 Tinkering.** Look up a single target.

### 🤖 Ask an AI assistant about this scraper

Pop this README into ChatGPT, Claude, or any AI assistant and ask it to map your specific workflow to the actor's inputs.

### ❓ Frequently Asked Questions

**❓ Need an API key?** No.

**❓ Source?** Official EBI ChEMBL REST API.

**❓ Schedule runs?** Yes.

**❓ Rate limits?** Light per-IP throttle.

**❓ API or scraping?** API.

**❓ Schema stability?** Stable.

**❓ Maximum run?** 1,000,000 records on paid plans.

**❓ Gene symbol?** Pulled from GENE\_SYMBOL synonyms in components.

**❓ Cross-references?** Yes, kept as array.

**❓ Download formats?** Any Apify dataset format.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST API or webhook endpoint.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge ChEMBL Assays Scraper](https://apify.com/parseforge) | ChEMBL bioactivity assays. |
| [ParseForge NPI Registry Scraper](https://apify.com/parseforge) | U.S. healthcare provider lookup. |
| [ParseForge SPDX Licenses Scraper](https://apify.com/parseforge) | License metadata. |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production-grade scrapers.

***

**Disclaimer.** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by the European Bioinformatics Institute. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

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

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

## `targetChemblId` (type: `string`):

Exact ChEMBL target id such as `CHEMBL203`. Skips list pagination.

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

Free-text search against the preferred name (uses the ChEMBL search endpoint).

## `organism` (type: `string`):

Exact organism filter, e.g. `Homo sapiens`.

## `targetType` (type: `string`):

ChEMBL target type filter.

## Actor input object example

```json
{
  "maxItems": 10,
  "targetType": ""
}
```

# 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/chembl-targets-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/chembl-targets-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/chembl-targets-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ChEMBL Targets Scraper",
        "description": "Query the ChEMBL target catalog by ID, keyword, organism, or target type. Records include target ChEMBL ID, preferred name, organism, target type, gene symbol, tax ID, components with accession and description, and cross references. Useful for drug discovery research and target review.",
        "version": "0.1",
        "x-build-id": "bhxKDjaqtlpPNqxtV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~chembl-targets-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-chembl-targets-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~chembl-targets-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-chembl-targets-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~chembl-targets-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-chembl-targets-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"
                    },
                    "targetChemblId": {
                        "title": "Target ChEMBL ID",
                        "type": "string",
                        "description": "Exact ChEMBL target id such as `CHEMBL203`. Skips list pagination."
                    },
                    "search": {
                        "title": "Search",
                        "type": "string",
                        "description": "Free-text search against the preferred name (uses the ChEMBL search endpoint)."
                    },
                    "organism": {
                        "title": "Organism",
                        "type": "string",
                        "description": "Exact organism filter, e.g. `Homo sapiens`."
                    },
                    "targetType": {
                        "title": "Target type",
                        "enum": [
                            "",
                            "SINGLE PROTEIN",
                            "PROTEIN COMPLEX",
                            "PROTEIN FAMILY",
                            "PROTEIN-PROTEIN INTERACTION",
                            "ORGANISM",
                            "CELL-LINE",
                            "TISSUE",
                            "NUCLEIC-ACID",
                            "SMALL MOLECULE",
                            "MACROMOLECULE",
                            "OLIGOSACCHARIDE",
                            "OLIGONUCLEOTIDE",
                            "PHENOTYPE",
                            "UNCHECKED"
                        ],
                        "type": "string",
                        "description": "ChEMBL target type filter.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```