# RxNorm Drug Normalizer (Name to RxCUI, Class, NDC) (`scrapers_lat/rxnorm-drug-normalizer-scraper`) Actor

Map any drug or brand name to standardized RxNorm concepts: RxCUI, active ingredients, brand names, clinical and branded drug forms, dose forms, strengths, plus NDC codes and ATC drug classes. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapers\_lat/rxnorm-drug-normalizer-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.56 / 1,000 normalized drug concepts

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![RxNorm Drug Normalizer (Name to RxCUI, Class, NDC)](https://scrapers.lat/banners/rxnorm-drug-normalizer-scraper.png)](https://console.apify.com/actors/nPH3bECH0F5H57gTD/input)

## RxNorm Drug Normalizer (Name to RxCUI, Class, NDC)

Here is one real result, with every field the actor returns:

```json
{
  "inputTerm": "Lipitor",
  "rxcui": "153165",
  "name": "Lipitor",
  "tty": "BN",
  "synonym": null,
  "isBranded": true,
  "ingredients": ["atorvastatin"],
  "ingredientCount": 1,
  "multiIngredients": [],
  "preciseIngredients": ["atorvastatin calcium trihydrate", "atorvastatin calcium"],
  "brandNames": ["Lipitor"],
  "genericForms": [
    "atorvastatin 80 MG Oral Tablet",
    "atorvastatin 20 MG Oral Tablet",
    "atorvastatin 40 MG Oral Tablet",
    "atorvastatin 10 MG Oral Tablet"
  ],
  "genericFormCount": 4,
  "brandedForms": [
    "atorvastatin 80 MG Oral Tablet [Lipitor]",
    "atorvastatin 10 MG Oral Tablet [Lipitor]",
    "atorvastatin 20 MG Oral Tablet [Lipitor]",
    "atorvastatin 40 MG Oral Tablet [Lipitor]"
  ],
  "brandedFormCount": 4,
  "doseForms": ["Oral Tablet", "Oral Product", "Pill"],
  "strengths": ["80 MG", "20 MG", "40 MG", "10 MG"],
  "ndcs": ["00071015823", "58151015877", "58864083430", "63629336601", "00071015523"],
  "ndcCount": 30,
  "drugClasses": [
    { "className": "Atorvastatin", "classType": "CHEM", "classId": "D000069059" },
    { "className": "Hydroxymethylglutaryl-CoA Reductase Inhibitors", "classType": "MOA", "classId": "N0000000121" },
    { "className": "Decreased Cholesterol Synthesis", "classType": "PE", "classId": "N0000008555" },
    { "className": "HMG CoA reductase inhibitors", "classType": "ATC1-4", "classId": "C10AA" },
    { "className": "HMG-CoA Reductase Inhibitor", "classType": "EPC", "classId": "N0000175589" }
  ],
  "atcClass": "HMG CoA reductase inhibitors",
  "atcClassId": "C10AA",
  "aiWhatItIs": null,
  "aiDrugClassPlain": null,
  "aiCommonUses": null,
  "aiNotes": null,
  "rxNavUrl": "https://mor.nlm.nih.gov/RxNav/search?searchBy=RXCUI&searchTerm=153165",
  "source": "RxNorm / RxNav (U.S. National Library of Medicine)",
  "observedAt": "2026-08-20T17:27:04.915Z",
  "error": null
}
```

The most complete drug name normalizer available. It maps any drug, brand, or ingredient name to its standardized RxNorm concept and returns every related concept RxNorm exposes (active ingredients, brand names, clinical and branded drug forms, dose forms, and strengths), plus optional National Drug Codes and full drug classification (ATC, EPC, mechanism of action, physiologic effect, and therapeutic class).

**[Input](https://apify.com/scrapers_lat/rxnorm-drug-normalizer-scraper/input-schema) · [Output](https://apify.com/scrapers_lat/rxnorm-drug-normalizer-scraper/output-schema) · [Pricing](https://apify.com/scrapers_lat/rxnorm-drug-normalizer-scraper/pricing) · [Examples](https://apify.com/scrapers_lat/rxnorm-drug-normalizer-scraper/examples)**

![Platform](https://img.shields.io/badge/platform-Apify-brightgreen) ![Coverage](https://img.shields.io/badge/coverage-RxNorm%20%2F%20RxNav-blue) ![Output](https://img.shields.io/badge/output-JSON%20%7C%20CSV%20%7C%20Excel-orange) ![Billing](https://img.shields.io/badge/billing-pay%20per%20result-purple)

### Table of contents

- [What it does](#what-it-does)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Example output record](#example-output-record)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing-and-limits)
- [FAQ and troubleshooting](#faq-and-troubleshooting)
- [More scrapers at scrapers.lat](#more-scrapers-at-scraperslat)

### What it does

Give it any messy drug name, brand name, or RxNorm concept ID and it returns a clean, standardized concept you can join on. For each input it resolves the RxNorm concept unique identifier (RxCUI) with exact then approximate matching, then groups every related concept by type:

- Active ingredients and precise ingredients (salt and hydrate forms)
- Brand names
- Clinical drug forms (generic, such as "atorvastatin 10 MG Oral Tablet")
- Branded drug forms (such as "atorvastatin 10 MG Oral Tablet \[Lipitor]")
- Dose forms (tablet, capsule, oral solution, injection, and more)
- Strengths parsed from the drug forms
- A branded flag so you can split generic from brand concepts

Two opt-in add-ons enrich each concept further: National Drug Codes (NDC) drawn from the packaged drug products, and full drug classification (ATC, established pharmacologic class, mechanism of action, physiologic effect, chemical structure, and therapeutic class). A plain-language AI summary is also available.

You can drive it by drug name, by RxCUI, or both in one run. One record is returned per input.

### Quickstart

Paste this input to normalize three common drugs with NDC codes and drug classes:

```json
{
  "drugNames": ["metformin", "Lipitor", "ibuprofen"],
  "includeNdcAndClass": true,
  "maxResults": 10
}
```

### Input reference

| Name | Type | Required | Description | Example |
| --- | --- | --- | --- | --- |
| `drugNames` | array of strings | one of drugNames or rxcuis | Drug, brand, or ingredient names to normalize. Each is resolved to its RxNorm concept. | `["metformin", "Lipitor"]` |
| `rxcuis` | array of strings | one of drugNames or rxcuis | Exact RxNorm concept identifiers (RxCUI) to look up directly. | `["6809", "153165"]` |
| `includeNdcAndClass` | boolean | no | Add-on. Also fetch NDC codes and drug classes for each concept. Off by default, paid plans only. | `true` |
| `includeAiSummary` | boolean | no | Add-on. Add an AI plain-language read of each drug (educational, not medical advice). Off by default, paid plans only. | `true` |
| `maxResults` | integer | no | Maximum concepts to return in one run. Free plans are capped at 10. | `10` |

### Output reference

| Name | Type | Description |
| --- | --- | --- |
| `inputTerm` | string | The drug name or RxCUI you supplied |
| `rxcui` | string | RxNorm concept unique identifier |
| `name` | string | Standardized RxNorm concept name |
| `tty` | string | RxNorm term type (IN, BN, SCD, SBD, and so on) |
| `synonym` | string | Concept synonym, if any |
| `isBranded` | boolean | Whether the concept is a brand-level concept |
| `ingredients` | array | Active ingredient names |
| `ingredientCount` | integer | Number of active ingredients |
| `multiIngredients` | array | Multi-ingredient combinations the concept appears in |
| `preciseIngredients` | array | Precise ingredient names (salts and hydrates) |
| `brandNames` | array | Brand names for this concept |
| `genericForms` | array | Clinical drug forms (SCD) |
| `genericFormCount` | integer | Number of clinical drug forms |
| `brandedForms` | array | Branded drug forms (SBD) |
| `brandedFormCount` | integer | Number of branded drug forms |
| `doseForms` | array | Dose forms (tablet, capsule, and so on) |
| `strengths` | array | Strengths parsed from the drug forms |
| `ndcs` | array | National Drug Codes (NDC add-on) |
| `ndcCount` | integer | Number of NDC codes returned (NDC add-on) |
| `drugClasses` | array | Drug classes with className, classType, classId (class add-on) |
| `atcClass` | string | Primary ATC class name (class add-on) |
| `atcClassId` | string | Primary ATC class code (class add-on) |
| `aiWhatItIs` | string | AI plain-language description (AI add-on) |
| `aiDrugClassPlain` | string | AI drug class in everyday words (AI add-on) |
| `aiCommonUses` | string | AI common uses (AI add-on) |
| `aiNotes` | string | AI neutral note (AI add-on) |
| `rxNavUrl` | string | RxNav concept page URL |
| `source` | string | Data source |
| `observedAt` | string | When this record was captured |
| `error` | string | Error message, if any |

### Example output record

```json
{
  "inputTerm": "metformin",
  "rxcui": "6809",
  "name": "metformin",
  "tty": "IN",
  "isBranded": false,
  "ingredients": ["metformin"],
  "brandNames": ["Glucophage", "Janumet", "Kombiglyze"],
  "doseForms": ["Extended Release Oral Tablet", "Oral Solution", "Oral Tablet"],
  "strengths": ["500 MG", "1000 MG", "2.5 MG"],
  "ndcs": ["00310612560", "00310614530", "00310613530"],
  "ndcCount": 25,
  "atcClass": "Biguanides",
  "atcClassId": "A10BA",
  "drugClasses": [
    { "className": "Biguanides", "classType": "ATC1-4", "classId": "A10BA" }
  ],
  "source": "RxNorm / RxNav (U.S. National Library of Medicine)",
  "observedAt": "2026-08-20T17:27:04.915Z",
  "error": null
}
```

### Run via API and CLI

Start a run with the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~rxnorm-drug-normalizer-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"drugNames":["metformin","Lipitor","ibuprofen"],"includeNdcAndClass":true,"maxResults":10}'
```

Or with the Apify CLI:

```bash
apify call scrapers_lat/rxnorm-drug-normalizer-scraper \
  --input '{"drugNames":["metformin","Lipitor"],"includeNdcAndClass":true}'
```

### Fetch results

Read the dataset items from a finished run:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN&format=json"
```

Swap `format=json` for `csv` or `xlsx` to export a spreadsheet.

### Billing and limits

- Pay per result. You are charged for each normalized drug concept the actor returns.
- Add-ons are opt-in and paid plans only. NDC codes and drug classes are billed per concept only when real data is returned. The AI summary is billed per concept only when a usable summary is produced.
- Never charged on failure. An unresolved or unknown drug name returns an error row and is not billed.
- Free Apify plans are capped at 10 concepts per run, with add-ons disabled.
- The actor respects your run spend limit and stops returning billable results once it is reached.

### FAQ and troubleshooting

**What is an RxCUI?** It is the stable numeric identifier RxNorm assigns to a drug concept. It is the key you use to join drug data across systems.

**Can I look up a brand and get the generic?** Yes. Input a brand such as "Lipitor" and you get its ingredients (atorvastatin), clinical forms, branded forms, strengths, and classes.

**Why is my drug not found?** Free-text names are resolved with exact then approximate matching. Very unusual spellings or non-drug terms may not resolve and return an error row (no charge). Try the generic ingredient name or a known RxCUI.

**Where do NDC codes come from?** They are drawn from the packaged clinical and branded drug products related to your concept, so ingredient-level inputs still return real package codes.

**Is the AI summary medical advice?** No. It is a short educational, plain-language description only. It never includes dosing or clinical advice.

### More scrapers at scrapers.lat

We build clean, complete data scrapers priced per result. Explore the full catalog at [scrapers.lat](https://scrapers.lat).

This actor is not affiliated with or endorsed by the U.S. National Library of Medicine. It reads public RxNorm and RxNav data and returns it in a structured form.

# Actor input Schema

## `drugNames` (type: `array`):

One or more drug, brand or ingredient names to normalize, for example "metformin", "Lipitor", "ibuprofen". Each name is resolved to its RxNorm concept (exact then approximate match). One record is returned per name. At least one of Drug Names or RxCUIs is required.

## `rxcuis` (type: `array`):

One or more exact RxNorm concept identifiers (RxCUI) to look up directly, for example "6809" (metformin) or "153165" (Lipitor). One record is returned per RxCUI.

## `includeNdcAndClass` (type: `boolean`):

Also fetch National Drug Codes (NDC) and drug classes (ATC, EPC, mechanism of action, physiologic effect) for each concept. Opt-in add-on, billed per concept only when real NDC or class data is returned. Available to paid Apify plans.

## `includeAiSummary` (type: `boolean`):

Add an AI-written plain-language read of each drug (what it is, drug class in everyday words, common uses, a neutral note). Educational only, not medical advice. Opt-in add-on, billed per concept only when a usable summary is produced. Available to paid Apify plans.

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

Maximum number of drug concepts to return in one run (across Drug Names and RxCUIs). Free Apify plans are capped at 10.

## Actor input object example

```json
{
  "drugNames": [
    "metformin",
    "Lipitor",
    "ibuprofen"
  ],
  "rxcuis": [
    "6809",
    "153165"
  ],
  "includeNdcAndClass": false,
  "includeAiSummary": false,
  "maxResults": 10
}
```

# 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 = {
    "drugNames": [
        "metformin",
        "Lipitor",
        "ibuprofen"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/rxnorm-drug-normalizer-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 = {
    "drugNames": [
        "metformin",
        "Lipitor",
        "ibuprofen",
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/rxnorm-drug-normalizer-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "drugNames": [
    "metformin",
    "Lipitor",
    "ibuprofen"
  ],
  "maxResults": 10
}' |
apify call scrapers_lat/rxnorm-drug-normalizer-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/rxnorm-drug-normalizer-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nPH3bECH0F5H57gTD/builds/Rj5GwQjmasOHhM4S4/openapi.json