# PubChem Compound - Chemical & Drug Data | $0.002 (`pink_comic/pubchem-compound-search`) Actor

Search PubChem for chemical compound data. Find compounds by name, formula, or structure. For chemists, pharma researchers, toxicologists, and materials scientists. Pay per result.

- **URL**: https://apify.com/pink\_comic/pubchem-compound-search.md
- **Developed by:** [Ava Torres](https://apify.com/pink_comic) (community)
- **Categories:** Developer tools, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## PubChem Compound Search

Search 115M+ chemical compounds from NIH PubChem. Look up compounds by name, molecular formula, SMILES notation, or PubChem CID. Returns molecular properties including weight, IUPAC name, canonical SMILES, InChI, XLogP, TPSA, hydrogen bond counts, and more. No API key required.

---

### Data Source

NIH PubChem PUG REST API (pubchem.ncbi.nlm.nih.gov). PubChem is the world's largest publicly accessible chemical database, maintained by the National Center for Biotechnology Information (NCBI) as part of the National Institutes of Health.

---

### Output Fields

Output fields depend on the selected **Property Set**.

#### Basic Properties
| Field | Type | Description |
|---|---|---|
| `cid` | integer | PubChem Compound ID |
| `molecularFormula` | string | Molecular formula (e.g., C9H8O4) |
| `molecularWeight` | number | Molecular weight in g/mol |
| `canonicalSMILES` | string | Canonical SMILES notation |
| `isomericSMILES` | string | Isomeric SMILES notation |
| `iupacName` | string | IUPAC systematic name |
| `inchi` | string | InChI identifier |
| `inchiKey` | string | Hashed InChIKey (27 characters) |

#### Physical Properties (adds to Basic)
| Field | Type | Description |
|---|---|---|
| `xLogP` | number | Octanol-water partition coefficient |
| `exactMass` | number | Exact monoisotopic mass |
| `tpsa` | number | Topological polar surface area (A^2) |
| `hBondDonorCount` | integer | Number of hydrogen bond donors |
| `hBondAcceptorCount` | integer | Number of hydrogen bond acceptors |
| `rotatableBondCount` | integer | Number of rotatable bonds |

#### All Properties (adds to Physical)
| Field | Type | Description |
|---|---|---|
| `monoisotopicMass` | number | Monoisotopic mass |
| `heavyAtomCount` | integer | Number of non-hydrogen atoms |
| `complexity` | number | Structural complexity score |
| `charge` | integer | Formal charge |

---

### Use Cases

- **Drug discovery and cheminformatics** -- retrieve molecular properties for compound screening, ADMET analysis, or structure-activity relationship (SAR) research.
- **Chemical database integration** -- pull structured compound data into internal databases, ELN systems, or research workflows.
- **Regulatory and safety documentation** -- retrieve InChI, InChIKey, SMILES, and molecular formula for compound identification in regulatory filings.
- **Academic research** -- access compound properties for computational chemistry, machine learning training data, or literature-related compound lookups.
- **Pharmaceutical market intelligence** -- look up drug compound structures and properties for competitive analysis or formulation research.
- **Educational tools** -- build chemistry reference tools that surface structured property data for any compound by name.

---

### How to Use

Set the input fields and run the actor. Results are pushed to the Apify dataset and can be exported as JSON, CSV, or Excel.

#### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchType` | string | `name` | `name` (compound name), `formula` (molecular formula), `smiles` (SMILES notation), or `cid` (PubChem CID) |
| `query` | string | | Search term. Required for all search types |
| `properties` | string | `all` | Property set to retrieve: `basic`, `physical`, or `all` |
| `maxResults` | integer | `10` | Maximum compounds to return (1-200) |

#### Example -- Look Up a Drug by Name

```json
{
  "searchType": "name",
  "query": "aspirin",
  "properties": "all",
  "maxResults": 1
}
````

#### Example -- Search by Molecular Formula

```json
{
  "searchType": "formula",
  "query": "C9H8O4",
  "properties": "physical",
  "maxResults": 10
}
```

#### Example -- Search by SMILES

```json
{
  "searchType": "smiles",
  "query": "CC(=O)OC1=CC=CC=C1C(O)=O",
  "properties": "basic",
  "maxResults": 5
}
```

#### Example -- Direct CID Lookup

```json
{
  "searchType": "cid",
  "query": "2244",
  "properties": "all",
  "maxResults": 1
}
```

***

### Cost

- **Actor start fee:** ~$0.10 per run
- **Compute:** minimal -- typical runs complete in seconds
- **Data cost:** $0.005 per result

Most lookups cost under $0.15 total.

***

### Output Formats

Results are available in the Apify dataset viewer and can be exported as:

- JSON
- CSV
- Excel (XLSX)
- XML
- RSS

***

### FAQ

**Do I need an NIH or PubChem account?**
No. PubChem's PUG REST API is fully public and requires no authentication.

**How many compounds does PubChem contain?**
PubChem contains over 115 million unique compounds as of 2024. It is the largest publicly accessible chemical database in the world.

**What is an InChIKey?**
The InChIKey is a fixed-length, hashed representation of the full InChI identifier. It is widely used as a stable, searchable identifier for chemical compounds across databases and publications.

**What is XLogP?**
XLogP is the calculated octanol-water partition coefficient, a key measure of lipophilicity used in drug discovery and ADMET property prediction. Higher values indicate greater lipophilicity.

**What is TPSA?**
Topological Polar Surface Area is the sum of the surface area contributed by polar atoms. It is used to predict intestinal absorption, blood-brain barrier penetration, and other pharmacokinetic properties.

**Can I search for drugs by brand name?**
Yes. PubChem includes synonyms for many compounds including brand names, generic names, and chemical names. Searching by brand name (e.g., `Tylenol`, `Lipitor`) will return the corresponding compound record.

**What is the maximum number of results per run?**
The maximum is 200 compounds per run. For name-based searches PubChem typically returns the closest matching compound first.

# Actor input Schema

## `searchType` (type: `string`):

How to search the compound database.

## `query` (type: `string`):

Compound name (e.g. 'aspirin'), molecular formula (e.g. 'C9H8O4'), SMILES (e.g. 'CC(=O)OC1=CC=CC=C1C(O)=O'), or CID (e.g. '2244').

## `properties` (type: `string`):

Which molecular properties to retrieve.

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

Maximum number of compounds to return (1-200).

## Actor input object example

```json
{
  "searchType": "name",
  "query": "aspirin",
  "properties": "all",
  "maxResults": 10
}
```

# 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 = {
    "searchType": "name",
    "query": "aspirin",
    "properties": "all",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("pink_comic/pubchem-compound-search").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 = {
    "searchType": "name",
    "query": "aspirin",
    "properties": "all",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("pink_comic/pubchem-compound-search").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 '{
  "searchType": "name",
  "query": "aspirin",
  "properties": "all",
  "maxResults": 10
}' |
apify call pink_comic/pubchem-compound-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PubChem Compound - Chemical & Drug Data | $0.002",
        "description": "Search PubChem for chemical compound data. Find compounds by name, formula, or structure. For chemists, pharma researchers, toxicologists, and materials scientists. Pay per result.",
        "version": "0.1",
        "x-build-id": "PvsmySNyimLJfxPxc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pink_comic~pubchem-compound-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pink_comic-pubchem-compound-search",
                "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/pink_comic~pubchem-compound-search/runs": {
            "post": {
                "operationId": "runs-sync-pink_comic-pubchem-compound-search",
                "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/pink_comic~pubchem-compound-search/run-sync": {
            "post": {
                "operationId": "run-sync-pink_comic-pubchem-compound-search",
                "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",
                "required": [
                    "query"
                ],
                "properties": {
                    "searchType": {
                        "title": "Search Type",
                        "enum": [
                            "name",
                            "formula",
                            "smiles",
                            "cid"
                        ],
                        "type": "string",
                        "description": "How to search the compound database.",
                        "default": "name"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Compound name (e.g. 'aspirin'), molecular formula (e.g. 'C9H8O4'), SMILES (e.g. 'CC(=O)OC1=CC=CC=C1C(O)=O'), or CID (e.g. '2244').",
                        "default": "aspirin"
                    },
                    "properties": {
                        "title": "Property Set",
                        "enum": [
                            "basic",
                            "physical",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which molecular properties to retrieve.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of compounds to return (1-200).",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
