Clinical data infrastructure
ICD-10, medications, conditions, and benefits on one key — every record mapped to the others and re-audited against its source. The connected data layer behind modern health products: it powers our own eligibility engine, and it’s the foundation the next one gets built on.
$0 to start · no card · live in 2 minutes
$ curl -X POST data.eleplan.com/v1/benefits/screen \
-d '{"state":"TX","age":34,"income_annual":28000,"pregnant":true}'
{
"state": "TX",
"results": [
{ "slug": "medicaid-pregnancy", "name": "Medicaid — Pregnancy",
"level": "state", "verdict": "likely",
"reasons": ["income < 200% FPL", "pregnant"],
"is_estimate": true },
{ "slug": "wic", "name": "WIC", "level": "federal",
"verdict": "likely",
"reasons": ["pregnant", "income < 185% FPL"] }
]
}Four curated datasets on one key — ICD-10, drugs, conditions, benefits — each cross-walked to the others, not just sitting side by side.
98,000+codes
Semantic search, full hierarchy, billable flags, instructional notes, and CMS-HCC risk adjustment (RAF).
/v1/icd10/search
27,000+medications
Every strength + form, ATC + FDA class, FAERS safety signal, and a multi-drug interaction checker with risk scoring. Built on RxNorm + OpenFDA.
/v1/drugs/products/search
1,000+conditions
Plain-language references, grounded in MedlinePlus (NIH) and mapped to ICD-10.
/v1/conditions/search
2,800+programs
Federal + state assistance with structured eligibility. Pass a person’s profile to the “am I eligible?” screening engine and get back ranked, qualifying programs with how to apply.
/v1/benefits/screen
Anyone can download the government files.
The value is everything after.
Three things turn a pile of public datasets into one layer you build on — and they’re the reason the eligibility engine further down is even possible.
Every record knows its neighbors. ICD-10 ↔ CMS-HCC risk, drug ↔ RxNorm ↔ interactions, condition ↔ codes, benefit ↔ eligibility gates — the relationships that live in no single source, resolved for you.
The corpus re-checks itself. Every source is re-pulled on a schedule and reconciled against its authority; each record carries the date it was last verified, and a program that disappears upstream retires itself.
Eligibility prose read by machine into typed gates. Free-text label warnings into a scored interaction graph. FPL thresholds pulled live from HHS. The hard parts arrive as fields, not paragraphs.
One record. Every connection. No join keys to maintain.
Start anywhere and the data walks to its neighbors — because the cross-references are built in, reconciled against a second authority before they ship.
That traversal is the product. A condition resolves to its codes, the codes carry their risk weight, the drugs that treat it come interaction-checked, and the programs a patient might qualify for are already mapped in — one key, one shape, reconciled.
The hardest thing a connected, current corpus makes possible: real eligibility.
You can’t build this on a static program list — it needs the cross-walks (condition + income → eligibility gates) and the self-audit (FPL thresholds, live from HHS). One POST /v1/benefits/screen takes a person’s profile — age, income, household, state, conditions — and returns the federal and state programs they actually qualify for, each ranked with the reasons it matched.
POST /v1/benefits/screen{
"state": "TX",
"age": 34,
"household_size": 3,
"income_annual": 28000,
"pregnant": true,
"conditions": ["gestational diabetes"]
}{
"state": "TX",
"results": [
{ "slug": "medicaid-pregnancy",
"name": "Medicaid — Pregnancy",
"level": "state", "verdict": "likely",
"reasons": ["income < 200% FPL", "pregnant"] },
{ "slug": "wic",
"name": "WIC", "level": "federal",
"verdict": "likely",
"reasons": ["pregnant", "income < 185% FPL"] },
{ "slug": "snap",
"name": "SNAP", "level": "federal",
"verdict": "possible",
"reasons": ["household of 3"] }
]
}Every result carries the reasons it matched and an is_estimate flag — decision support for navigators and care teams, not a legal determination.
Sourced from the authorities — cleaned, cross-walked, and kept current by Eleplan.
Every dataset starts from its canonical source, then we normalize the formats, resolve the cross-references (ICD-10 ↔ HCC, drug ↔ RxNorm, condition ↔ code), validate, and version it — so you ship against one clean, current shape instead of a dozen government file formats.
It’s the same data discipline behind Eleplan — the platform families and care teams use to manage serious, complex care. This API is its data layer.
See what Eleplan does →How it’s built
We didn’t scrape this. We built it.
Anyone can download a government CSV. The hard part — the part that makes it usable — is everything after. Built the way the commercial clinical databases are (First Databank, Medi-Span) — multi-source, normalized, cross-walked — but open, semantic, and free.
RxNorm drug identity, openFDA labels, RxClass therapeutic classes, 20M FAERS safety reports, CMS ICD-10 + risk adjustment — combined, not just cited.
Collapse salt forms to base ingredients on RxNorm identity — one clean record per drug, not 135k duplicate NDC stubs.
Drugs ⇄ ICD-10 indications, products ⇄ ingredient hubs, conditions ⇄ codes — the relationships that live in no single source.
Free-text label warnings become typed fields — a scored, pairwise drug-interaction graph built from narrative text.
Every record vectorized with pgvector, so you search by meaning — “what lowers blood sugar” → metformin.
Tracked sources, last-checked dates, scheduled rebuilds — and cross-walked mappings reconciled against a second, independent authority (NLM MED-RT / UMLS). Corroborated, not generated once and trusted.
That’s the difference between a data dump and a data product.
Built once isn’t enough.
The corpus audits itself.
Government data drifts — programs close, thresholds change, eligibility gets rewritten. So this doesn’t ship once and rot. Scheduled workers re-check every source against its authority, and an AI layer turns the eligibility prose no API could parse into fields you can filter.
Every source is re-pulled on a schedule — a weekly federal sweep, hourly rolling state shards — then reconciled against the upstream. A program that disappears from the authority retires itself, and every record carries the date it was last verified.
A model reads each program’s eligibility prose and extracts typed gates — age, income, condition — so “who qualifies” becomes a field you can filter, not a paragraph you parse. Conservative by design: it surfaces requirements, it never invents them.
Income eligibility is computed as a share of the official HHS Federal Poverty Level — pulled straight from the ASPE guidelines API and refreshed every year, no annual hand-edit — for the contiguous states, Alaska, and Hawaii.
Federal listings from SAM.gov, the USA.gov Benefit Finder model, and state assistance networks — fused, cross-walked to ICD-10, and corroborated against a second source before anything ships.
An eligibility layer that stays true to the agencies — without you watching the agencies.
Search 98,000+ codes in plain English.
Type a condition the way a person would. The API resolves it to the right ICD-10 code — with a featured best match and the full hierarchy behind it.
Live results from the ICD-10 dataset — every code links to its free public reference page. The production API returns the same JSON, authenticated by key.
Check drug interactions in one call.
Pass a medication list — get the interactions between them, a duplicate-therapy check, and a risk score, synthesized from FDA labeling. Powers /v1/drugs/interactions.
Comma-separate 2+ medications — generic or brand.
Explain a condition in one call.
Search a condition in plain language — get a clear summary, its ICD-10 codes, and the medications used for it, grounded in MedlinePlus (NIH). Powers /v1/conditions/search.
Live results from the Conditions dataset — plain-language summaries from MedlinePlus (NIH), each mapped to ICD-10 and the medications used for it. Every result links to its free public page.
Find assistance programs in one call.
Search federal & state assistance programs in plain language — get who qualifies, how to apply, and the conditions each one covers, cross-walked to ICD-10. Powers /v1/benefits/search.
Live results from the Benefits dataset — federal & state assistance programs with eligibility and how-to-apply, each mapped to ICD-10 and the conditions it covers. Every result links to its free public page.
Write, not just read.
Beyond the four read datasets, push your own notes and documents straight into a project — auto-OCR’d, parsed, and indexed alongside everything else. Powers POST /v1/ingest.
Ingest writes into an Eleplan project — create a plan in the app, then push notes & documents to it from your code.
POST /v1/ingest
curl -X POST https://data.eleplan.com/v1/ingest \
-H "Authorization: Bearer elp_..." \
-H "Content-Type: application/json" \
-d '{
"project_id": 1234,
"items": [{ "title": "Visit summary", "body": "..." }],
"files": [{ "filename": "labs.pdf", "mime": "application/pdf",
"data_url": "data:application/pdf;base64,..." }]
}'Any clinical document, turned into structured data.
Send a PDF, scan, photo, or recording. Request a presigned URL, PUT the file straight to storage, then process — we OCR it, summarize it, and extract the medications, events, and contacts inside, stored securely against your account.
Upload → process /v1/documents
# 1 · presigned upload URL (free)
curl -X POST https://data.eleplan.com/v1/documents/upload-url \
-H "Authorization: Bearer elp_..." \
-d '{ "filename": "discharge.pdf", "mime": "application/pdf" }'
# → { "document_id": 8412, "upload_url": "https://…",
# "status": "awaiting_upload" }
# 2 · PUT the file straight to storage (no size limit)
curl -X PUT "$upload_url" --data-binary @discharge.pdf
# 3 · OCR + extraction (billed here)
curl -X POST https://data.eleplan.com/v1/documents/8412/process \
-H "Authorization: Bearer elp_..."
# → { "status": "processing", "link": "https://eleplan.link/aB12xY" }Built for PHI from the first request.
The reference datasets are public — your lookups carry no PHI. The data you push in — documents, notes — is treated like the sensitive health information it is.
Every request is TLS. Every uploaded file lands in encrypted storage (AES-256) — never a public bucket.
API keys are stored only as SHA-256 hashes — we never keep the raw key, so a database compromise can’t expose a working one. Scope each key per dataset; revoke it instantly.
Pushing into a project takes more than a key: your account must own the project, and the caller must be an account admin with full access on it. Reads of the public datasets need none of that.
We don’t sell it, broker it, or train public AI models on it. Documents you upload belong to your account; reference lookups aren’t tied to a person.
Every vendor that can touch PHI runs under a signed Business Associate Agreement — AWS (encrypted storage + OCR) and OpenAI (the optional AI extraction). Most APIs send your data to OpenAI with no BAA at all.
150,000+ pages you
don’t have to build.
Every ICD-10 code, drug, condition, and assistance program has a public, human-readable reference page — plus pages for how they connect: which drugs treat a condition, a medication’s side effects, and which benefits may apply. Fully indexed, always current, and free with every plan. Deep-link or embed ours.
The hard parts, already done.
Query in plain language — "type 2 diabetes", "knee pain" — and get the right code. pgvector under the hood, not keyword matching.
Verified data with last-checked dates. We track the source so you don’t parse government files yourself.
Clean, typed JSON with hierarchy, eligibility, and relationships — the parts that are hard to build, done.
A single API key spans every API — the four datasets, ingest, and document processing (OCR + clinical extraction). Scope it per API, with its own monthly limit.
Not just names. Every strength and form, ATC + FDA class, real-world FAERS safety signal, ICD-10 cross-walks, and a multi-drug interaction checker with risk scoring.
150,000+ ICD-10, drug, condition, and benefit pages — plus the relationships between them: which drugs treat a condition, common side effects, and which benefits apply. Public, indexed, human-readable. Deep-link or embed ours, free on every plan.
One request. Clean JSON.
Authenticate with a bearer token, hit an endpoint, get typed JSON. No SDK required — though they’re coming.
# One key, every dataset. Each returns { results, bestMatch }.
AUTH='-H "Authorization: Bearer elp_live_..."'
curl $AUTH "https://data.eleplan.com/v1/icd10/search?q=type+2+diabetes"
curl $AUTH "https://data.eleplan.com/v1/drugs/search?q=metformin"
curl $AUTH "https://data.eleplan.com/v1/conditions/search?q=type+2+diabetes"
curl $AUTH "https://data.eleplan.com/v1/benefits/search?q=food+assistance"Every parameter and field — across every API.
$ curl data.eleplan.com/v1/icd10/E11.9 \
-H "Authorization: Bearer elp_live_..."
{
"code": "E11.9",
"title": "Type 2 diabetes mellitus without complications",
"billable": true,
"risk_adjustment": { "cms_hcc_v28": { "hcc": "HCC38", "raf": 0.166 } },
…
}That’s one field group. The full reference covers every parameter and response field — across ICD-10, drugs, conditions, benefits, ingest, and the Documents API.
Full API reference — free with an API key →Every parameter and field across every API, in your dashboard.
5,165 healthcare icons — free.
One coherent, fully-accessible family across 21 clinical domains — symptoms, meds, vitals, labs, behavioral, cognitive, dementia, caregiving, RPM/CCM, AI signals, and more. Outline + filled, theme-colored SVG. Continuously AI-curated — recurring passes refine naming, categories, and search. Use them in any app, commercial or not.
Start free. Scale when you ship.
$0
For prototyping.
$19/mo
The full data layer.
$49.99/mo
Everything, plus the flagship.
Custom
For platforms at scale.
The 150,000+ public reference pages and all 5,165 healthcare icons are free on every plan — no key required.
The reference data behind modern health products — without the 50-state, multi-agency grind.
Get an API key