canonical: https://jentic.com/apis/doctofam.com/doctofam

# Doctofam API

The Doctofam API manages the records of a medical practice: patients, appointments, clinics, procedures, invoices, and payments. It lists, creates, and retrieves patient records and appointments, records invoices and payments, and reports the clinics and procedures available. Webhook-subscription operations push practice events to your own systems.

## For AI agents

Manage a medical practice with Doctofam: list and create patients and appointments, retrieve clinics and procedures, record invoices and payments, and subscribe to practice webhooks.

## Scope

Does not handle clinical lab results, e-prescribing, or insurance claim adjudication. Use for managing patient records, appointments, and billing in a medical practice only.

## Capabilities

- List, create, and retrieve patient records
- Book and retrieve appointments for a patient
- Create and retrieve invoices and record payments
- List clinics and the procedures they offer
- Create, update, and delete webhook subscriptions for practice events

## Use cases

### Agent Practice Assistant

An AI agent connected through Jentic looks up a patient, books their appointment, and raises the matching invoice. The Doctofam API exposes the patient, appointment, and invoice operations the agent needs, and Jentic injects the credential at call time so the agent never holds the key.

Example prompt: Look up a patient by listing patients, create an appointment for them, and create the corresponding invoice

### Billing and Payments

Front-desk workflows raise invoices and record payments as they come in. The Doctofam API creates and retrieves invoices and payments, so an agent can reconcile a patient's balance against the services recorded.

Example prompt: Create an invoice for a completed procedure and record the patient's payment against it

### Practice Event Webhooks

Integrations react to new appointments and patients as they happen. The Doctofam API creates, updates, and deletes webhook subscriptions, so an agent can keep downstream systems notified of practice events.

Example prompt: Create a webhook subscription for appointment events and confirm it was registered

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/patients` | List patients |
| POST | `/api/patients` | Create a patient |
| GET | `/api/appointments` | List appointments |
| POST | `/api/appointments` | Create an appointment |
| GET | `/api/invoices` | List invoices |
| POST | `/api/invoices` | Create an invoice |
| POST | `/api/payments` | Create a payment |
| POST | `/api/webhooksubscriptions` | Create a webhook subscription |

## Key resources

- **Patients** — List, create, and retrieve patient records
- **Appointments** — List, create, and retrieve appointments
- **Invoices and payments** — Create and retrieve invoices and record payments
- **Clinics and procedures** — List clinics and the procedures they offer
- **Webhook subscriptions** — Create, update, and delete webhook subscriptions

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 54 / 100
  - Agent Usability: 94 / 100
  - Security: 30 / 100
  - AI Discoverability: 78 / 100
- **View full report:** https://jentic.com/apis/doctofam.com/doctofam/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Doctofam by hand means base64-encoding your API key secret for HTTP Basic auth, switching to the `Authorization`-header apiKey for webhook operations, and tracking per-resource scopes yourself. Through Jentic you install once, import Doctofam from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** Doctofam puts resource ids like the patient id in the URL path, so a rule can bound your agent to specific read paths and operations. Limit the agent to the operations it needs, such as listing and reading patients and appointments, so write operations like creating invoices or deleting webhook subscriptions are not included unless you add them.
- **Credential handling:** Your Doctofam credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list patients' or 'create an appointment', and Jentic returns the matching Doctofam operation with its input schema so the agent calls the right endpoint directly.

## Related APIs

- **DrChrono** — DrChrono is a full EHR and practice-management platform, while Doctofam offers a lighter practice records API.
- **athenahealth** — athenahealth provides enterprise EHR and revenue-cycle APIs, overlapping with Doctofam's practice records.
- **Medcorder** — Medcorder captures and structures patient-visit recordings that can complement Doctofam's records.

## FAQ

### What authentication does the Doctofam API use?

The Doctofam API authenticates with HTTP Basic auth, sending your base64-encoded API key secret, per its OpenAPI spec. Webhook-subscription operations instead use an apiKey credential in the `Authorization` header. Each key carries per-resource scopes, such as read access to patients or write access to appointments. Through Jentic the credential is stored encrypted by your own Jentic One instance and injected at execution time, so it never enters the agent's prompt or logs.

### Can I manage patients and appointments with the Doctofam API?

Yes. The API lists, creates, and retrieves patient records and appointments, reports the clinics and procedures available, and records invoices and payments. Webhook subscriptions can notify your systems when practice events occur.

### Is there a Doctofam MCP server?

You don't need an MCP server to give your agent the Doctofam API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls the patient, appointment, and billing operations. Operations load on demand, so your agent's context stays lean instead of holding another server's tool definitions.

### Can I limit what my agent is allowed to do with the Doctofam API?

Yes. Write a rule that allows only the read operations for patients, appointments, and invoices, so the agent can look up practice data but cannot create patients, record payments, or change webhook subscriptions. Every call the agent makes is logged.

### What are the rate limits for the Doctofam API?

The OpenAPI spec does not specify rate limits. Check the Doctofam documentation at https://doctofam.com for current limits before running high-volume record or billing jobs.

### How do I book an appointment with the Doctofam API through Jentic?

Search Jentic for an intent like 'create an appointment', add the Doctofam API from the directory, and store your credential once. Your agent then looks up the patient and creates the appointment and any invoice. To run it on your own infrastructure, install Jentic One from its GitHub repo.