# ICD-10 Codes Scraper | Medical Diagnosis Lookup (`parseforge/icd10-codes-scraper`) Actor

Extract ICD-10-CM diagnosis codes with code, short and long descriptions, chapter, block, and parent hierarchy. Filter by chapter or keyword. Built for medical billing software, healthcare apps, clinical research, and AI training datasets in the health sector.

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

## Pricing

from $19.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.
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)

## 🩺 ICD-10 Codes Reference Scraper

> 🚀 **Export ICD-10-CM and ICD-10-PCS codes in seconds.** Search by diagnosis name, condition keyword, or code prefix. Backed by the official U.S. National Library of Medicine clinical-table service. Download as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-25 · **📊 6 fields** per record · ICD-10-CM, ICD-10-PCS, ICD-9-CM · 70,000+ clinical codes

The **ICD-10 Codes Scraper** queries the U.S. National Library of Medicine's public Clinical Table Search Service to return ICD-10-CM (diagnoses), ICD-10-PCS (procedures), and the legacy ICD-9-CM systems. Every record contains the code, full description, and a deep link to the public reference.

**Coverage:** 70,000+ ICD-10-CM diagnosis codes, ICD-10-PCS procedure codes, and ICD-9-CM legacy codes.

---

### Target Audience / Use Cases

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Healthcare developers | Auto-complete code lookup widgets |
| Medical billers | Bulk export of codes for billing systems |
| Clinical analysts | Build code dictionaries for cohort studies |
| Healthtech startups | Seed databases with canonical codes |
| Insurance/claims teams | Map free-text diagnoses to codes |
| Educators | Teaching datasets for clinical informatics |

---

### 📋 What the ICD-10 Codes Scraper does

- Search across ICD-10-CM, ICD-10-PCS, ICD-9-CM diagnosis and procedure tables
- Returns code + canonical description for each match
- Streamed via NLM's official Clinical Table API
- Filters by free-text search (matches both code prefix and description)
- Exports in JSON, CSV, Excel, or XML

> 💡 **Why it matters:** Coding tables are foundational, but extracting them in bulk from official sources usually means crawling PDF appendices. This actor returns them as clean JSON instantly.

---

### 🎬 Full Demo

_🚧 Coming soon_

---

### ⚙️ Input

<table>
<thead><tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr></thead>
<tbody>
<tr><td><code>searchTerm</code></td><td>string</td><td>No</td><td>diabetes</td><td>Keyword or code prefix.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>10</td><td>Max records. Free users capped at 10.</td></tr>
<tr><td><code>codeSystem</code></td><td>select</td><td>No</td><td>icd10cm</td><td>Which code system.</td></tr>
</tbody>
</table>

**Example 1 - Every ICD-10 diabetes-related code:**
```json
{ "searchTerm": "diabetes", "maxItems": 500, "codeSystem": "icd10cm" }
````

**Example 2 - All ICD-10-PCS procedures matching "appendectomy":**

```json
{ "searchTerm": "appendectomy", "codeSystem": "icd10pcs", "maxItems": 100 }
```

> ⚠️ **Good to Know:** The NLM API ranks matches by relevance. Use specific keywords (e.g. `type 2 diabetes`) for precise filters.

***

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📛 `title` | string | `code — description` |
| 🆔 `code` | string | ICD code |
| 🏷️ `codeSystem` | string | `icd10cm`, `icd10pcs`, `icd9cm_dx`, `icd9cm_sg` |
| 📄 `description` | string | Official description |
| 🔗 `sourceUrl` | string | Deep-link to a public reference |
| 🕒 `scrapedAt` | string | ISO timestamp |
| ❌ `error` | string | Error if any |

Sample:

```json
{ "title": "E08.00 — Diabetes mellitus due to underlying condition with hyperosmolarity without nonketotic hyperglycemic-hyperosmolar coma (NKHHC)", "code": "E08.00", "codeSystem": "icd10cm", "description": "Diabetes mellitus due to underlying condition with hyperosmolarity without nonketotic hyperglycemic-hyperosmolar coma (NKHHC)" }
```

***

### ✨ Why choose this Actor

- 🟢 Official NLM clinical-table source - canonical descriptions
- 🟢 No API key or registration
- 🟢 Three code systems in a single actor
- 🟢 Paginates fully through up to 1,000,000 codes
- 🟢 Clean JSON / CSV / Excel / XML output

***

### 📈 How it compares to alternatives

| Option | Free | Multiple systems | Bulk export | Up-to-date |
|---|---|---|---|---|
| CMS code download | Free | Yes | Yes (raw CSV) | Annual |
| Paid coding APIs | No | Yes | Yes | Yes |
| **ParseForge ICD-10 Scraper** | **Yes** | **Yes** | **JSON/CSV/Excel/XML** | **Yes** |

***

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open this actor on Apify Console
3. Enter a search term or leave empty
4. Run, download CSV / Excel / JSON / XML
5. Schedule or integrate

***

### 💼 Business use cases

#### Billing & RCM

Seed billing systems with the full ICD-10-CM table.

#### Cohort building

Map free-text patient notes to code candidates with `searchTerm`.

#### Healthtech onboarding

Populate code dropdowns instantly.

#### Education

Provide students with structured code tables.

***

### 🔌 Automating ICD-10 Codes Scraper

Integrates with **Make**, **Zapier**, **n8n**, **Slack**, **Airbyte**, **GitHub Actions**, **Google Drive**, and any HTTP-aware tool through the Apify API.

***

### 🌟 Beyond business use cases

#### Research

Build research code dictionaries for epidemiology studies.

#### Personal

Look up a diagnosis or procedure code quickly.

#### Non-profit

Seed open-source health data tools.

#### Experimentation

Combine with CMS reimbursement data for cost modeling.

***

### 🤖 Ask an AI assistant about this scraper

ChatGPT · Claude · Perplexity · Microsoft Copilot

***

### ❓ Frequently Asked Questions

**Q: Where does the data come from?**
The U.S. National Library of Medicine's Clinical Table Search Service.

**Q: Do I need an API key?**
No.

**Q: Are descriptions current?**
Yes, the source updates with the official annual CMS releases.

**Q: How many codes are available?**
70,000+ in ICD-10-CM alone, plus ICD-10-PCS procedures and ICD-9-CM legacy codes.

**Q: Can I do a code-prefix search?**
Yes, pass the prefix as `searchTerm`.

**Q: Is medical billing advice included?**
No. This actor returns the published code dictionaries only.

**Q: Output formats?**
JSON, CSV, Excel, XML.

**Q: Free preview?**
Yes, 10 records for free users.

**Q: Can I get CPT or SNOMED codes?**
Not in this actor. The NLM service exposes ICD-9 and ICD-10 systems.

**Q: Pagination?**
Handled automatically up to `maxItems`.

***

### 🔌 Integrate with any app

Webhooks, REST API, Make, Zapier, Slack, Airbyte, Google Sheets, and more.

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [CDC WONDER Mortality Scraper](https://apify.com/parseforge/cdc-wonder-mortality-scraper) | US mortality counts and rates |
| [ClinicalTrials.gov Scraper](https://apify.com/parseforge/clinicaltrials-scraper) | Registered clinical trials worldwide |
| [Health Canada Drugs Scraper](https://apify.com/parseforge/health-canada-drug-database-scraper) | Canadian drug product database |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the U.S. National Library of Medicine or the Centers for Medicare & Medicaid Services. Only publicly available reference data is collected.

# Actor input Schema

## `searchTerm` (type: `string`):

Search text (code prefix or condition name). Leave empty to enumerate codes.

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

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

## `codeSystem` (type: `string`):

Which clinical code system to query.

## Actor input object example

```json
{
  "searchTerm": "diabetes",
  "maxItems": 10,
  "codeSystem": "icd10cm"
}
```

# Actor output Schema

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

Scraped ICD-10 Codes Reference Scraper - Diagnoses & Procedures records

# 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 = {
    "searchTerm": "diabetes",
    "maxItems": 10,
    "codeSystem": "icd10cm"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/icd10-codes-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 = {
    "searchTerm": "diabetes",
    "maxItems": 10,
    "codeSystem": "icd10cm",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/icd10-codes-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 '{
  "searchTerm": "diabetes",
  "maxItems": 10,
  "codeSystem": "icd10cm"
}' |
apify call parseforge/icd10-codes-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ICD-10 Codes Scraper | Medical Diagnosis Lookup",
        "description": "Extract ICD-10-CM diagnosis codes with code, short and long descriptions, chapter, block, and parent hierarchy. Filter by chapter or keyword. Built for medical billing software, healthcare apps, clinical research, and AI training datasets in the health sector.",
        "version": "0.1",
        "x-build-id": "v10XFmdfY13ig30vg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~icd10-codes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-icd10-codes-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~icd10-codes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-icd10-codes-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~icd10-codes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-icd10-codes-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": {
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Search text (code prefix or condition name). Leave empty to enumerate codes."
                    },
                    "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"
                    },
                    "codeSystem": {
                        "title": "Code System",
                        "enum": [
                            "icd10cm",
                            "icd10pcs",
                            "icd9cm_dx",
                            "icd9cm_sg"
                        ],
                        "type": "string",
                        "description": "Which clinical code system to query."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
