A medical reasoning API returns a clinical answer together with an auditable chain-of-thought and peer-reviewed citations. EvidenceMD is the first medical reasoning API: it is OpenAI-compatible, grounds answers in PubMed, clinical guidelines, and peer-reviewed journals, and exposes the reasoning behind each recommendation. Point the OpenAI SDK at https://evidencemd.ai/api/v1, authenticate with an x-api-key header, and build clinical copilots, differential-diagnosis engines, AI scribes, triage, decision support, and more — with verifiable evidence in every response.
Key takeaways
- EvidenceMD is the first medical reasoning API — it returns a clinical answer, a transparent chain-of-thought, and peer-reviewed citations, not just retrieved text.
- It is OpenAI-compatible: point the OpenAI SDK at https://evidencemd.ai/api/v1, authenticate with an x-api-key header, and call evidencemd-fast, evidencemd-pro, or evidencemd-deep.
- You can build clinical copilots, differential-diagnosis engines, AI scribes, triage, EHR decision support, prior-auth assistants, research tools, agents, and education products — all with citations built in.
- JSON mode returns typed answer + sources fields, so results drop straight into EHRs, dashboards, and agentic workflows.
- It is free to start and HIPAA-aligned with a BAA for eligible plans — confirm PHI scope and covered endpoints before sending production patient data.
Why “reasoning” is the category that matters for medicine
Most healthcare AI APIs are either general model layers or retrieval boxes. A reasoning API is a different thing.
Retrieval alone hides the reasoning
RAG assistants retrieve passages and summarize them, but the clinical logic that connects the evidence to the recommendation stays invisible. For medicine, the reasoning is the part a clinician most needs to check.
General models have no clinical grounding
OpenAI, Claude, and Gemini APIs return fluent answers from model memory with no sources and no guarantee of clinical accuracy. Building grounding, citation behavior, and evaluation on top is your team's cost.
A reasoning API returns answer + reasoning + sources
EvidenceMD reasons over peer-reviewed evidence and returns all three, so the output is verifiable end to end. That is why it is a reasoning API, not a search box or a text generator.
Why not just use OpenAI or Claude?
You can — but you become the medical layer. EvidenceMD is medically fine-tuned with evidence grounding and citations built in, so you ship clinical features without the heavy prompt engineering, retrieval, and evaluation scaffolding a general model requires.
Medically fine-tuned, not just prompted
EvidenceMD is fine-tuned for clinical reasoning, not a general model steered by a long system prompt. In a 2026 Nature Communications study, supervised fine-tuning outperformed prompt engineering for diagnostic accuracy — and GPT-4o and Claude “fell short in dynamic diagnostic workflows and frequently committed clinical errors.”
Evidence and citations are built in
Every clinical answer returns peer-reviewed citations and a transparent chain-of-thought by default. With OpenAI or Claude you build the retrieval, source-ranking, citation formatting, and clinical evaluation yourself — and still get no guarantee of grounding.
Far less prompt engineering and scaffolding
Because clinical behavior is trained in, you skip the brittle mega-prompts, few-shot exemplars, and eval harnesses teams bolt onto general models. Point the OpenAI SDK at EvidenceMD, pick a model, and ship — the clinical layer is already there.
- GPQA Diamond scientific reasoning (internal evaluation) — where PhD domain experts score ~70%
- 97%GPQA Diamond scientific reasoning (internal evaluation) — where PhD domain experts score ~70%
- State-of-the-art results on the HealthBench Hard clinical benchmark
- SOTAState-of-the-art results on the HealthBench Hard clinical benchmark
- Reasoning tokens on evidencemd-deep for complex, multi-step clinical analysis
- 64kReasoning tokens on evidencemd-deep for complex, multi-step clinical analysis
GPQA Diamond figure from EvidenceMD internal evaluation (graduate-level scientific reasoning, where PhD domain experts score ~70%). See the benchmarks.
The short version: use a general API (OpenAI, Claude, Gemini) when you want one model across general, administrative, and clinical tasks and are ready to build grounding and safety yourself. Use EvidenceMD when the spec is “return an evidence-backed clinical answer, a differential, or a note — with citations” and you want it to work out of the box.
Quickstart: one request away
Call the OpenAI-compatible endpoint with your API key. Works with the official OpenAI SDK by changing the base URL.
curl https://evidencemd.ai/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"model": "evidencemd-pro",
"messages": [
{"role": "user", "content": "72M with dyspnea, orthopnea, and bilateral crackles. Differential?"}
],
"include_thinking": true,
"stream": true
}'from openai import OpenAI
# Drop-in: the official OpenAI SDK, pointed at EvidenceMD.
client = OpenAI(
base_url="https://evidencemd.ai/api/v1",
api_key="unused", # auth travels in the x-api-key header
default_headers={"x-api-key": "YOUR_API_KEY"},
)
resp = client.chat.completions.create(
model="evidencemd-pro",
messages=[
{"role": "user", "content": "First-line treatment for community-acquired pneumonia?"}
],
)
# The message carries the answer plus inline peer-reviewed citations.
print(resp.choices[0].message.content){
"model": "evidencemd-deep",
"specialty": "cardiology",
"response_format": { "type": "json_object" },
"messages": [
{ "role": "user",
"content": "Return a ranked differential with evidence for this presentation..." }
]
}
// Response: a clean JSON object your EHR or dashboard can render directly.
{
"answer": "...",
"differential": [ { "diagnosis": "...", "likelihood": "...", "evidence": "..." } ],
"sources": [ { "title": "...", "journal": "NEJM", "url": "https://pubmed..." } ]
}What the API gives you out of the box
Transparent clinical chain-of-thought
Set include_thinking to stream the model's step-by-step clinical reasoning. Reviewers and end users can audit how a recommendation was reached — the defining feature of a reasoning API versus an opaque general model.
Peer-reviewed citations in every clinical answer
Responses include inline citations and a structured sources list from PubMed, clinical guidelines, NEJM, JAMA, and The Lancet, so your product renders verifiable references instead of unsourced text.
OpenAI-compatible, drop-in
Point the official OpenAI SDK at the EvidenceMD base URL and authenticate with an x-api-key header. Switching from a generic model to medical reasoning is a base-URL and key change.
Structured JSON mode
Request response_format json_object to receive a clean answer field plus a sources array — ideal for EHRs, dashboards, and downstream automation that needs typed fields, not prose.
Three models for cost and depth
evidencemd-fast for quick cited answers, evidencemd-pro for deep analysis, and evidencemd-deep with 64k reasoning tokens for complex, multi-step clinical questions.
Specialty-aware and multilingual
Pass a specialty for tailored responses and choose from 30 languages for global clinical and patient-facing workflows — from a single endpoint.
What you can build with the EvidenceMD API
Ten features teams ship on a medical reasoning API — each one able to show verifiable evidence, not just an answer.
Clinical copilot & point-of-care Q&A
evidencemd-pro · include_thinking · streamingEmbed an evidence-grounded assistant that answers clinical questions with visible citations and reasoning. Because sources travel with the answer, clinicians verify in-context instead of leaving your product — no retrieval pipeline or citation prompt-scaffolding to build.
See clinical reasoningDifferential diagnosis engine
evidencemd-deep · response_format json_object · specialtySend symptoms, history, labs, and imaging findings; get a ranked differential where each possibility carries its supporting evidence. This is exactly where general models stumble — peer-reviewed studies show off-the-shelf LLMs fail most on differentials — so a fine-tuned reasoning model matters.
How differential diagnosis AI worksAI medical scribe with clinical documentation integrity
evidencemd-pro · JSON mode · citationsTurn an encounter into a structured note where the assessment and plan are backed by reasoning and citations — not just transcription. The same clinical layer flags gaps, supporting clinical documentation integrity (CDI) and coding accuracy.
See the EvidenceMD AI scribeMultilingual patient education & discharge instructions
evidencemd-fast · language · specialtyGenerate reading-level-appropriate education and discharge instructions in 30 languages, grounded in guidelines so the guidance stays clinically accurate. One endpoint serves both the clinician-facing and patient-facing sides of the workflow.
Telehealth triage & symptom checker
evidencemd-fast → escalate to pro · streamingRoute intake with a symptom checker that reasons about red flags and urgency and cites the evidence behind its recommendation. Start on evidencemd-fast for latency, then escalate high-risk cases to pro or deep for a fuller reasoning pass.
EHR-embedded clinical decision support
evidencemd-pro · response_format json_objectSurface decision support inside the chart as typed JSON your UI maps to discrete fields — alerts, suggested orders, evidence links — rather than free text. Citations travel with each suggestion so clinicians see why, not just what.
Best clinical decision support AIPrior authorization & coding assistant
evidencemd-pro · JSON mode · citationsDraft prior-authorization justifications and coding suggestions with the supporting evidence attached, so submissions carry a defensible, sourced rationale. The transparent reasoning is what makes the output reviewable by a human before it ships.
Literature synthesis & research tooling
evidencemd-deep · include_thinkingBuild tools that synthesize peer-reviewed evidence across PubMed and journals and expose the reasoning path between sources. evidencemd-deep's 64k reasoning tokens suit multi-step synthesis for research and evidence-review workflows.
See EvidenceMD benchmarksAgentic clinical workflows
OpenAPI spec · JSON mode · tool useRegister EvidenceMD as a tool in an agent stack using the machine-readable OpenAPI spec, and let agents call a medical reasoning step with citations mid-workflow. The structured answer + sources shape makes results safe to chain into downstream automation.
View the OpenAPI specMedical education & board prep
evidencemd-pro · include_thinkingCreate teaching tools that show the full clinical chain-of-thought behind an answer, so learners see how an expert reasons — not just the final choice. Transparent reasoning turns every question into a worked example with cited evidence.
Reasoning API vs general LLM API vs RAG API
How a purpose-built medical reasoning API compares to a general-purpose model API and a retrieval-and-summarize (RAG) API for building clinical features.
| Capability | EvidenceMD (reasoning) | General LLM API | RAG API |
|---|---|---|---|
| Returns a clinical answer | |||
| Peer-reviewed citations in response | |||
| Transparent, auditable chain-of-thought | Limited | ||
| Purpose-built for medicine | Varies | ||
| OpenAI-compatible drop-in | Itself | Varies | |
| Structured JSON answer + sources | Generic | Varies | |
| Specialty-aware + 30 languages | |||
| Prompt engineering & eval scaffolding needed | Minimal | Heavy | Moderate |
| Best for | Shipping cited clinical features fast | General apps + custom clinical layer | Search over your own corpus |
Swipe the table horizontally to see more →
Comparison reflects publicly documented API behavior as of 2026. “RAG API” refers to retrieval-and-summarize services; capabilities vary by provider — verify during procurement.
Models: pick for cost and depth
evidencemd-fast1 creditQuick answers with peer-reviewed citations and the fastest response time. Great for autocomplete-style Q&A and patient-facing chat.
evidencemd-pro2 creditsDeep analysis with comprehensive citations and chain-of-thought. The default for differentials and treatment planning.
evidencemd-deep4 credits64k reasoning tokens and 97% GPQA Diamond (internal evaluation) for complex, multi-step clinical analysis.
A common pattern: default to evidencemd-fast and escalate high-stakes queries to evidencemd-pro or evidencemd-deep.
Build responsibly
A medical reasoning API augments — it does not replace — a qualified clinician's judgment. Keep a human in the loop for clinical decisions, surface the citations and reasoning so users can verify, and confirm HIPAA scope, data-retention terms, and BAA coverage before sending identifiable patient information in production. EvidenceMD is HIPAA-aligned with a BAA available for eligible plans.
Frequently asked questions
What is a medical reasoning API?
A medical reasoning API is an API that returns clinical answers with an explicit, auditable chain-of-thought and peer-reviewed citations — not just retrieved text. EvidenceMD is the first transparent medical reasoning API: instead of only retrieving and summarizing a corpus, it shows the step-by-step clinical reasoning behind each answer and grounds recommendations in PubMed, NEJM, JAMA, The Lancet, and clinical guidelines. It is OpenAI-compatible, so developers integrate it with the same SDKs they already use.
How is a reasoning API different from a general LLM API or a RAG API?
General LLM APIs (OpenAI, Claude, Gemini) return fluent answers from model memory with no clinical grounding or sources. Retrieval-augmented generation (RAG) APIs add citations by summarizing retrieved passages, but the reasoning between the sources stays hidden. A medical reasoning API like EvidenceMD does both and exposes the reasoning: it retrieves peer-reviewed evidence, reasons over it with a transparent chain-of-thought, and returns the answer, the reasoning, and the sources — so the output is verifiable rather than a black box.
How do I call the EvidenceMD medical reasoning API?
The EvidenceMD API is OpenAI-compatible. Point the official OpenAI SDK (or any HTTP client) at the base URL https://evidencemd.ai/api/v1, authenticate with an x-api-key header, and call POST /chat/completions with a model of evidencemd-fast, evidencemd-pro, or evidencemd-deep. Streaming, JSON mode (response_format json_object), a transparent chain-of-thought (include_thinking), a specialty parameter, and 30 languages are supported. Get a key and read the docs at https://evidencemd.ai/developers.
What can I build with the EvidenceMD API?
You can build clinical copilots and point-of-care Q&A, differential-diagnosis engines, AI medical scribes with clinical documentation integrity support, multilingual patient-education and discharge tools, telehealth triage and symptom checkers, EHR-embedded decision support, prior-authorization and coding assistants, literature-synthesis and research tools, agentic clinical workflows, and medical-education products. Because the API returns citations and reasoning, each of these features can show verifiable evidence rather than an unsourced answer.
Why not just use OpenAI or Claude with a good prompt?
You can, but you become the medical layer: with a general API you build the retrieval, source-ranking, citation formatting, clinical evaluation, and safety scaffolding yourself, and still have no guarantee of grounding. EvidenceMD is medically fine-tuned with evidence and citations built in, so you skip most of that. Peer-reviewed research supports the difference — a 2026 Nature Communications study found supervised fine-tuning outperformed prompt engineering for diagnostic accuracy, and that general models like GPT-4o and Claude fell short on dynamic diagnostic workflows. Use a general API when one model must serve general, administrative, and clinical tasks; use EvidenceMD when you need evidence-backed clinical answers out of the box.
Which model should I use — evidencemd-fast, evidencemd-pro, or evidencemd-deep?
Use evidencemd-fast (1 credit) for quick, cited answers where latency matters, such as autocomplete-style Q&A and patient-facing chat. Use evidencemd-pro (2 credits) for deep analysis with comprehensive citations and chain-of-thought, such as differential diagnosis and treatment planning. Use evidencemd-deep (4 credits) for complex, multi-step clinical questions that benefit from 64k reasoning tokens and the highest reasoning accuracy. Many products route to fast by default and escalate to pro or deep for high-stakes queries.
Does the API return citations and the model's reasoning?
Yes. Clinical responses include inline citations and a structured sources list drawn from PubMed, clinical guidelines, and peer-reviewed journals, so your product can render verifiable references. Setting include_thinking streams the model's step-by-step clinical chain-of-thought, so end users and reviewers can audit how a recommendation was reached — the core reason to choose a reasoning API over an opaque general model.
Is the EvidenceMD API HIPAA compliant, and can I send patient data?
EvidenceMD is HIPAA-aligned: data is encrypted in transit and at rest, and a Business Associate Agreement (BAA) is available for eligible plans. As with any clinical API, confirm the current compliance documentation, data-retention terms, covered endpoints, and BAA scope with EvidenceMD before sending identifiable patient information (PHI) in production.
How much does the medical reasoning API cost?
The EvidenceMD API is free to start, then usage-based with a simple credit model: evidencemd-fast costs 1 credit per call, evidencemd-pro 2 credits, and evidencemd-deep 4 credits. A free starting tier lets teams evaluate clinical quality before committing. See https://evidencemd.ai/pricing and https://evidencemd.ai/developers for current limits and plans.
Documentation and sources
Primary sources for the API capabilities described on this page.
Related reading
Build on the first medical reasoning API
Evidence-based clinical reasoning with peer-reviewed citations and a transparent chain-of-thought, in an OpenAI-compatible API. Free to start.
Get your API key