DocInfo APIdocinfo.org ↗
Search DocInfo (FSMB) for physicians and PAs. Retrieve licenses, board certifications, education, locations, and board actions via 2 JSON endpoints.
What is the DocInfo API?
The DocInfo API exposes 2 endpoints that cover the Federation of State Medical Boards' practitioner database, returning structured profiles with up to 14 response fields per doctor. Use search_doctors to find physicians or physician assistants by name — optionally filtered to a single U.S. state — and then pass the returned doctor_id to get_doctor_profile to pull education, board certifications, active state licenses, reported locations, and any state medical board disciplinary actions.
curl -X GET 'https://api.parse.bot/scraper/424dc68e-a74d-4a62-bb34-3aaaa58d4161/search_doctors?name=John+Smith&practitioner_type=physician' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace docinfo-org-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: DocInfo doctor lookup — search by name, drill into full profile."""
from parse_apis.docinfo_org_api import DocInfo, PractitionerType, UpstreamError
client = DocInfo()
# Search for physicians matching a name, capped to 5 results.
for doc in client.doctor_summaries.search(name="John Smith", practitioner_type=PractitionerType.PHYSICIAN, limit=5):
locs = ", ".join(f"{loc.city}, {loc.state}" for loc in doc.locations)
print(f"{doc.full_name} ({doc.degree}) — {locs}")
# Drill down: take the first result and fetch its full profile.
summary = client.doctor_summaries.search(name="John Smith", limit=1).first()
if summary is not None:
try:
profile = summary.details()
except UpstreamError as e:
print(f"Could not fetch profile: {e.message}")
profile = None
if profile is None:
print("Profile unavailable, skipping detail view.")
else:
print(f"\n{profile.full_name}, {profile.degree}")
if profile.education is not None:
print(f" School: {profile.education.medical_school} ({profile.education.graduation_year})")
print(f" Active licenses: {', '.join(profile.active_licenses)}")
print(f" Certifications: {', '.join(profile.certifications)}")
print(f" Board actions: {profile.board_action_count}")
print("\nexercised: doctor_summaries.search / details / doctors.get (via details)")
Searches DocInfo for physicians and/or physician assistants whose name matches the given text, optionally restricted to practitioners licensed in one U.S. state or territory. Returns one row per practitioner with the opaque doctor_id, full name, degree code (e.g. MD, DO, PA) and the practitioner's reported city/state locations. One round trip. The site returns only the top 30 best-matching practitioners for a query and offers no further pages, so `count` is at most `max_results` (30); narrow the name or set license_state to see more specific results. A name with no matches yields an empty `doctors` array. Location cities/states are reported historically and may not reflect a current practice address.
| Param | Type | Description |
|---|---|---|
| namerequired | string | Practitioner name text to match (first, last, or full name). |
| license_state | string | Full name of a U.S. state or territory as spelled in the site's state selector (one shape: Texas). Restricts results to practitioners licensed in that state. Omitted or `all` = no state restriction. |
| practitioner_type | string | Which practitioner category to search. Omitted = physicians only. |
{
"type": "object",
"fields": {
"name": "the name text that was searched",
"count": "number of practitioners returned",
"doctors": "array of matching practitioners: doctor_id (GUID string, input for get_doctor_profile), full_name, degree (MD/DO/PA/... code), locations (array of {city, state})",
"max_results": "the site's fixed cap on returned matches (30)",
"license_state": "the license-state restriction applied (`all` when none)",
"practitioner_type": "the practitioner category applied"
},
"sample": {
"data": {
"name": "John Smith",
"count": 2,
"doctors": [
{
"degree": "MD",
"doctor_id": "7020f3d8-8590-49a3-b564-7d2569805f4a",
"full_name": "Lawrence John Smith",
"locations": [
{
"city": "Eagle River",
"state": "Alaska"
},
{
"city": "Anchorage",
"state": "Alaska"
}
]
},
{
"degree": "MD",
"doctor_id": "e6b63294-56f5-40f1-a82a-c79192fb3513",
"full_name": "Stephen John Smith",
"locations": [
{
"city": "Langhorne",
"state": "Pennsylvania"
}
]
}
],
"max_results": 30,
"license_state": "all",
"practitioner_type": "physician"
},
"status": "success"
}
}About the DocInfo API
Searching for Practitioners
search_doctors accepts a name string (first, last, or full name) and returns up to 30 matching practitioners per query — the site's fixed cap, reflected in the max_results field. Each result includes a doctor_id GUID, full_name, and degree code (MD, DO, PA, and others). You can narrow results with license_state (full state name, e.g. Texas) or practitioner_type to include physician assistants alongside physicians. The response also echoes back the filters applied as license_state and practitioner_type fields.
Retrieving Full Profiles
get_doctor_profile takes a single doctor_id and returns the complete DocInfo profile in one response. Key fields include education (medical school name and graduation year, either of which may be null when not reported), certifications (array of board certification names), active_licenses (array of state names), and locations (array of city/state pairs). Gender is returned as M or F when the source reports it, otherwise null.
Board Actions
Disciplinary history is surfaced through two fields: board_action_count gives the total number of actions across all states, and board_actions_by_state provides a structured array with each entry containing the state name, a direct URL to that state's medical board, and a nested actions array of individual records with order_date and action text. When a practitioner has no board actions, board_actions_by_state is an empty array and board_action_count is zero.
The DocInfo API is a managed, monitored endpoint for docinfo.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when docinfo.org changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official docinfo.org API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Verify that a physician holds an active license in a specific state before a telehealth appointment
- Screen practitioners for board disciplinary actions using
board_action_countandboard_actions_by_state - Build a credentialing workflow that checks board certifications from
certificationsalongside license status - Aggregate practitioner location data from
locationsfor provider directory mapping - Look up medical school and graduation year from the
educationobject for background verification - Filter search results to physician assistants using the
practitioner_typeparameter - Cross-reference active licenses across multiple states for multi-state practice compliance checks
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does DocInfo (FSMB) offer an official developer API?+
What does `get_doctor_profile` return for board actions, and how is it structured?+
get_doctor_profile returns a board_action_count integer for the total number of actions across all states, and a board_actions_by_state array. Each element in that array contains the state name, a state_board_url pointing to the relevant state medical board, and an actions array where each entry has an order_date and descriptive action text. If no actions exist, the array is empty and the count is zero.What is the maximum number of results `search_doctors` can return in one call?+
max_results field of the response. The API does not support pagination beyond this cap. If your query matches more than 30 practitioners, narrowing the search with license_state or a more specific name string will reduce the result set to the most relevant matches.Does the API expose DEA numbers, NPI numbers, or malpractice history?+
Can I retrieve historical or expired licenses, not just active ones?+
active_licenses field returns only currently active state licenses as reported by DocInfo. Expired or inactive licenses are not included in the response. You can fork this API on Parse and revise it to add handling for inactive license data if DocInfo surfaces it in a separate section of the profile.