# PubChem Compound Lookup & Normalizer (`wakey7dev/pubchem-compound-lookup`) Actor

Search and retrieve chemical compound data from PubChem (NIH). Returns normalized chemical properties (formula, MW, LogP, SMILES), categorized synonyms, and identifiers (CAS, UNII, InChIKey). No API key required - free open data from the US NIH.

- **URL**: https://apify.com/wakey7dev/pubchem-compound-lookup.md
- **Developed by:** [Chris Wakefield](https://apify.com/wakey7dev) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

![Chris The Dev](https://raw.githubusercontent.com/chriswakefield87/appstore-screenshot-translator/main/assets/actor-banner.png)

## PubChem Compound Lookup & Normalizer

Search and retrieve chemical compound data from **PubChem** — the world's largest free chemical database, maintained by the US National Institutes of Health (NIH). Returns normalized chemical properties, categorized synonyms, and standard identifiers.

**No API key required** — free and open data from the NIH.

### Why This Actor?

PubChem returns raw, complex data (atom-level structures, mixed-case names, catalog IDs). This Actor:
- **Cleans** — strips dosage info, suffixes, catalog numbers from names
- **Normalizes** — maps brand names (Ozempic → Semaglutide, Advil → Ibuprofen, Keytruda → Pembrolizumab) to generic names
- **Categorizes** — separates meaningful drug names from identifiers (CAS, UNII, ChEBI) and internal codes
- **Standardizes** — consistent camelCase property keys (molecularFormula, logP, smiles, etc.)
- **Identifies** — flags known drugs vs obscure compounds

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `compoundNames` | string[] | Aspirin, Ibuprofen, Paracetamol | One or more compound names or brand names to look up |
| `maxResults` | integer | 5 | Maximum compounds returned per search query |
| `includeSynonyms` | boolean | true | Include full synonym lists (names, identifiers, codes) |
| `includeProperties` | select | standard | Property level: basic, standard, or all |
| `normalizeNames` | boolean | true | Normalize brand→generic names and standardize formatting |

### Example Input

```json
{
  "compoundNames": ["Ozempic", "Keytruda", "Aspirin"],
  "maxResults": 3,
  "includeSynonyms": true,
  "includeProperties": "standard",
  "normalizeNames": true
}
````

### Example Output (Dataset Record)

```json
{
  "cid": 2244,
  "query": "Aspirin",
  "properties": {
    "molecularFormula": "C9H8O4",
    "molecularWeight": "180.16",
    "smiles": "CC(=O)OC1=CC=CC=C1C(=O)O",
    "inchikey": "BSYNRYMUTXBXSQ-UHFFFAOYSA-N",
    "iupacName": "2-acetyloxybenzoic acid",
    "logP": 1.2,
    "hBondDonors": 1,
    "hBondAcceptors": 4,
    "rotatableBonds": 3,
    "heavyAtomCount": 13
  },
  "normalizedName": "Aspirin",
  "isKnownDrug": true,
  "synonyms": {
    "names": ["aspirin", "ACETYLSALICYLIC ACID", "2-Acetoxybenzoic acid", ...],
    "identifiers": ["50-78-2", "UNII-R16CO5Y76E", "CHEBI:15365", "DB00945"],
    "codes": ["NSC27223", "NCGC00015067-01", ...]
  }
}
```

### Use Cases

- **Pharmaceutical R\&D** — drug property lookup and validation
- **Drug Discovery** — compound property screening
- **Chemical Informatics** — bulk compound data for ML/AI models
- **Healthcare Analytics** — drug identification and classification
- **Regulatory Compliance** — substance identification across global databases
- **Education & Research** — chemistry reference data for students and researchers
- **Drug Repurposing** — find compounds with similar properties to known drugs

### Data Source

[PubChem](https://pubchem.ncbi.nlm.nih.gov/) — an open chemistry database at the National Institutes of Health (NIH). Free, no API key required. Contains over 118 million compound substances with detailed chemical properties, synonyms, and 3D conformers.

**License:** PubChem data is available under the [NIH/NLM license](https://pubchem.ncbi.nlm.nih.gov/docs/data-usage-agreement) — free for commercial and non-commercial use.

### Normalization Features

- **200+ brand→generic mappings** (Ozempic→Semaglutide, Keytruda→Pembrolizumab, etc.)
- **Dosage/suffix stripping** (removes "mg", "tablet", "ER", "extended release", etc.)
- **Identifier categorization** (separates drug names from CAS, UNII, ChEBI, DrugBank codes)
- **Abbreviation expansion** (GLP-1→GLP-1 Receptor Agonist, SSRI→Selective Serotonin Reuptake Inhibitor)
- **Known drug flagging** — automatically marks compounds that match our drug database

# Actor input Schema

## `compoundNames` (type: `array`):

One or more compound names or brand names to look up (e.g. Aspirin, Ibuprofen, Ozempic, Paracetamol). Enter one per line.

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

Maximum compounds to return per search query (can include positional isomers).

## `includeSynonyms` (type: `boolean`):

Include full synonym lists for each compound (increases output size).

## `includeProperties` (type: `string`):

Level of chemical properties to return per compound. Basic includes formula, MW, SMILES, InChIKey. Standard adds LogP, HBD, HBA, RotBonds.

## `normalizeNames` (type: `boolean`):

Normalize brand-to-generic names and standardize case formatting.

## Actor input object example

```json
{
  "compoundNames": [
    "Aspirin",
    "Ibuprofen",
    "Paracetamol"
  ],
  "maxResults": 5,
  "includeSynonyms": true,
  "includeProperties": "standard",
  "normalizeNames": true
}
```

# Actor output Schema

## `results` (type: `string`):

All compound data records including normalized properties, synonyms, and identifiers.

## `summary` (type: `string`):

Formatted ASCII table of compound lookup results for quick review.

## `stats` (type: `string`):

Machine-readable stats about the lookup run.

# 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 = {
    "compoundNames": [
        "Aspirin",
        "Ibuprofen",
        "Paracetamol"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wakey7dev/pubchem-compound-lookup").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 = { "compoundNames": [
        "Aspirin",
        "Ibuprofen",
        "Paracetamol",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wakey7dev/pubchem-compound-lookup").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 '{
  "compoundNames": [
    "Aspirin",
    "Ibuprofen",
    "Paracetamol"
  ]
}' |
apify call wakey7dev/pubchem-compound-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PubChem Compound Lookup & Normalizer",
        "description": "Search and retrieve chemical compound data from PubChem (NIH). Returns normalized chemical properties (formula, MW, LogP, SMILES), categorized synonyms, and identifiers (CAS, UNII, InChIKey). No API key required - free open data from the US NIH.",
        "version": "1.0",
        "x-build-id": "e7QePVG4Qzf5VEH9R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wakey7dev~pubchem-compound-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wakey7dev-pubchem-compound-lookup",
                "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/wakey7dev~pubchem-compound-lookup/runs": {
            "post": {
                "operationId": "runs-sync-wakey7dev-pubchem-compound-lookup",
                "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/wakey7dev~pubchem-compound-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-wakey7dev-pubchem-compound-lookup",
                "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": [
                    "compoundNames"
                ],
                "properties": {
                    "compoundNames": {
                        "title": "Compound Names",
                        "type": "array",
                        "description": "One or more compound names or brand names to look up (e.g. Aspirin, Ibuprofen, Ozempic, Paracetamol). Enter one per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results Per Compound",
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum compounds to return per search query (can include positional isomers).",
                        "default": 5
                    },
                    "includeSynonyms": {
                        "title": "Include Synonyms",
                        "type": "boolean",
                        "description": "Include full synonym lists for each compound (increases output size).",
                        "default": true
                    },
                    "includeProperties": {
                        "title": "Output Properties",
                        "enum": [
                            "basic",
                            "standard",
                            "all"
                        ],
                        "type": "string",
                        "description": "Level of chemical properties to return per compound. Basic includes formula, MW, SMILES, InChIKey. Standard adds LogP, HBD, HBA, RotBonds.",
                        "default": "standard"
                    },
                    "normalizeNames": {
                        "title": "Normalize Drug Names",
                        "type": "boolean",
                        "description": "Normalize brand-to-generic names and standardize case formatting.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```