The dental clearinghouse for software companies.
Eligibility, claims, attachments, remittances and predeterminations through one JSON API. No X12 to write, no portals to scrape.
A sandbox key in minutes. Test mode never reaches a real payer and costs nothing.
curl "https://sandbox.myclaimhouse.com/api/v1/eligibility" \
-H "Authorization: Bearer $CLAIMHOUSE_KEY" \
-H "Idempotency-Key: $(uuidgen)" \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"office_id": "$OFFICE_ID",
"payer_id": "$PAYER_ID",
"subscriber": {
"first_name": "Sam",
"last_name": "Sample",
"date_of_birth": "1990-01-01",
"member_id": "CH-ACTIVE-FULL"
},
"procedure_codes": ["D0120", "D2740"]
}
EOF- Maximum left
- $2,000.00
- Deductible left
- $50.00
- D0120 periodic oral exam
- 100%
The answer, already read for you: plan, maximums, deductibles, coverage by category and by procedure code.
- 77API endpoints, each with an MCP tool
- 803dental payers in the directory
- 82MCP tools, with 5 that explain answers
- $0to build and test in the sandbox
Everything the API does, your agent can do.
The MCP server has a tool for every one of the 77 endpoints, plus 5 that explain answers, with the same key, permissions, validation, idempotency and errors as the API. Use it to operate claims, or to have an agent write your integration.
Connect the MCP server
Streamable HTTP with your API key as a bearer token. Nothing to install.
- Claude Code and Claude Desktop
- Cursor
- Your own agent, or any MCP client
Give it the docs
Machine-readable docs, so the agent uses real field names instead of guessing.
- OpenAPI 3.1 document/docs/openapi.json
- Every page in one file/docs/llms-full.txt
- Any docs page as markdown: add .md
Let it work, safely
The sandbox is the default, and you can see everything the agent did.
- A test key can only ever reach the sandbox
- Read or submit permissions per key
- Every tool call is logged
Find a payer called Delta, then check coverage for Sam Sample, born 1990-01-01, member ID CH-ACTIVE-FULL, at my test office for a D2740 crown. Tell me the remaining annual maximum and what the plan pays for the crown. Then try CH-NOT-FOUND and explain what to change.
Send a claim for that crown with my test office and its first provider, attach a bitewing X-ray, and tell me when the payer has answered and what it paid.
The whole dental revenue cycle, one integration.
Send JSON, get JSON back. Claim House writes the 837D, reads the 997, 277 and 835, and tells you what happened in plain fields.
Eligibility
Claims
Attachments
Remittances (ERAs)
Predeterminations
Claim status
Built the way you would have built it.
A clearinghouse that behaves like the other APIs you already use.
- 01REST and JSON. Snake_case fields, money as decimal strings, one error shape.
- 02Safe retries. Idempotency keys on every write, so a retry never sends a claim twice.
- 03Signed webhooks. Every state change is an event you can replay.
- 04A real sandbox. A payer network that answers, with scenarios you pick by member ID.
- 05One source of truth. The reference and the OpenAPI document are generated from the definitions the API checks requests with.
- 06SFTP too. Batch partners drop 837D files and collect 997, 277 and 835 files back.
{
"id": "evt_01JM000000E008000000000023",
"object": "event",
"type": "claim.accepted",
"sequence": 2,
"created_at": "2026-09-24T21:00:30.500000+00:00",
"data": {
"id": "clm_01JM000000E00800000000002G",
"object": "claim",
"office_id": "off_01JM000000E008000000000003",
"payer": {
"id": "pyr_01JM000000E008000000000004",
"payer_id": "00000",
"name": "Example Dental Plan"
},
"kind": "claim",
"state": "accepted_payer",
"previous_state": "accepted_clearinghouse",
"frequency": "original",
"parent_id": null,
"request_id": "req_01JM000000E00800000000002J",
"file": null,
"status": {
"category": "A2",
"code": "20"
},
"created_at": "2026-09-24T21:00:00.120000+00:00",
"occurred_at": "2026-09-24T21:00:30.400000+00:00"
}
}{
"mcpServers": {
"claimhouse": {
"url": "https://sandbox.myclaimhouse.com/api/mcp",
"headers": { "Authorization": "Bearer ${env:CLAIMHOUSE_KEY}" }
}
}
}Everything the API does, your team can see.
Support and billing staff work the same claims your code sends, without a second tool.
Claim detail
Open any claim and see what happened to it: what the payer paid and what the patient owes, every procedure line with its own status, and a timeline from created to reconciled.
- Download the 837D exactly as it was sent
- Correct or void the claim from the same page
- The raw X12 and the events it fired, one tab away
Claims
Every claim of every office in one list, with its state and what happens next in plain words. Filter by state, payer or office, or search by patient or control number.
- Validated claims queue for the next batch with one click
- Needs attention and rejected claims say what to change
- The same list your code sees through the API
Eligibility
The payer's answer laid out the way a front desk reads it: annual maximum and deductible remaining, coverage by category and by procedure code, and the network status.
- Rejections say what to fix, and you resend from the form
- Start a claim from the answer
- Check again with one click
Remittances
Each payment against the claims it pays, line by line, with every adjustment and its reason. Post it to your system, then mark it posted so nothing is counted twice.
- Payments matched to claims automatically
- Unmatched remittances are held for review, never dropped
- Mark it posted once it is in your system
Developers
Everything an integration needs on one page: API keys with their mode and permissions, webhook endpoints with a signing secret, the sandbox scenarios and the SFTP account.
- Test and live keys with read or submit permissions, revocable any time
- Signed webhooks, retried up to 8 times over about 24 hours
- A request log of every API and MCP call
803 dental payers, and you can check yours right now.
The directory is public. Search it without an account and see which transactions each payer supports and whether it needs enrollment.
Browse the payer networkPublished prices. Pay for what you send.
- Eligibility & benefits
- from $0.08
- Electronic claims
- $0.20
- Electronic attachments
- $0.30
- ERAs (835 remittances)
- $0.05
For teams building dental software.
AI and automation builders
Practice management systems
Dental billing companies
DSO technology teams
Patient data, handled like patient data.
Test and live kept apart
A test key can only ever reach the sandbox.
Roles for every teammate
Owner, admin, developer and viewer. The rules are enforced in the database, not only on the screen.
Scoped API keys
Each key has read or submit permissions and a mode. The full key is shown once, and you can revoke it at any time.
Signed webhooks
Every delivery carries a signature you can verify. The signing secret is shown once.
An audit trail
Changes to the account are recorded with who made them and when.
Send your first eligibility check in five minutes.
Create a sandbox account, copy a test key, and run the quickstart. Talk to us when you are ready to go live.