canonical: https://jentic.com/apis/doc.cheap/doc

# Doc Cheap Document Recognition API

The doc.cheap API recognizes documents and returns their extracted contents, charging only when a document is actually recognized. It submits a document for recognition, lists recent scans, fetches or deletes a stored scan by id, and reports the account balance and usage for the current period. A short-lived client token lets browsers or devices upload directly.

## For AI agents

Recognize documents and extract their contents with doc.cheap: submit a scan, list and fetch past scans, delete a stored scan, check usage, and issue client upload tokens.

## Scope

Does not handle document generation, e-signatures, or long-term file archival. Use for recognizing documents and extracting their contents only.

## Capabilities

- Recognize a document and return its extracted contents
- List recent scans and fetch a previous scan by id
- Delete a stored scan from the account
- Report the account balance and usage for the current billing period
- Issue a short-lived client token for browser or device uploads

## Use cases

### Agent Document Intake

An AI agent connected through Jentic submits an uploaded document to doc.cheap, waits for recognition, and reads the extracted contents into the workflow. The API returns the scan result and a billing flag so the agent knows whether the document was recognized, and Jentic injects the bearer token at call time.

Example prompt: Submit an invoice image to doc.cheap, fetch the resulting scan, and read the extracted fields

### Scan History and Cleanup

Teams processing many documents list recent scans, retrieve a specific result, and delete scans they no longer need. The doc.cheap API exposes scan listing, fetch-by-id, and delete so a workflow can keep stored results tidy.

Example prompt: List recent scans, fetch one by its id, and delete it once its data has been saved

### Usage Monitoring

Because recognition is billed per document, teams watch their balance and usage for the period. The doc.cheap API reports the current balance and usage so an agent can check remaining credits before a large batch.

Example prompt: Fetch the current usage and balance for the period and stop processing if credits are low

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/scans` | Recognize a document |
| GET | `/v1/scans` | List recent scans |
| GET | `/v1/scans/{id}` | Fetch a previous scan |
| DELETE | `/v1/scans/{id}` | Delete a stored scan |
| GET | `/v1/usage` | Balance and usage for the current period |
| POST | `/v1/client-tokens` | Issue a short-lived client token |

## Key resources

- **Scans** — Recognize a document and list, fetch, or delete stored scans
- **Usage** — Report the account balance and usage for the current period
- **Client tokens** — Issue short-lived tokens for direct browser or device uploads

## 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:** 74 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 75 / 100
  - AI-Readiness & Agent Experience: 59 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 81 / 100
- **View full report:** https://jentic.com/apis/doc.cheap/doc/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 doc.cheap by hand means managing its bearer token, deciding when to mint short-lived client tokens for uploads, and tracking per-document billing yourself. Through Jentic you install once, import doc.cheap from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Limit the agent to the operations it needs, such as recognizing documents and listing scans, so destructive operations like deleting a stored scan or issuing client tokens are not included unless you add them.
- **Credential handling:** Your doc.cheap token 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 'recognize a document' or 'check my usage', and Jentic returns the matching doc.cheap operation with its input schema so the agent calls the right endpoint directly.

## Related APIs

- **Mindee** — Mindee offers specialized document-parsing models, while doc.cheap offers flat per-document recognition.
- **Veryfi** — Veryfi extracts data from receipts and invoices, overlapping with doc.cheap's recognition.
- **OpenAI** — OpenAI models can reason over or summarize the text doc.cheap extracts.

## FAQ

### What authentication does the doc.cheap API use?

The doc.cheap API authenticates with a bearer token sent in the Authorization header, per its OpenAPI spec. You can also issue a short-lived client token for direct browser or device uploads. Through Jentic the token 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 extract data from documents with the doc.cheap API?

Yes. Submit a document to the recognition endpoint and the API returns its extracted contents along with a billing flag that indicates whether the document was recognized. You can then list, fetch, or delete the stored scan and check your remaining balance.

### Is there a doc.cheap MCP server?

You don't need an MCP server to give your agent the doc.cheap API. Jentic connects it directly from the API Directory: import it, store your bearer token once, and your agent calls the scan and usage 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 doc.cheap API?

Yes. Write a rule that allows only the recognize and list-scans operations, so the agent can submit documents and read results but cannot delete stored scans or issue client tokens. Every call the agent makes is logged.

### What are the rate limits for the doc.cheap API?

The OpenAPI spec does not specify rate limits; recognition is billed per recognized document with a free monthly allowance described in the spec. Check the doc.cheap documentation at https://doc.cheap for current limits and pricing before running a large batch.

### How do I recognize a document with the doc.cheap API through Jentic?

Search Jentic for an intent like 'recognize a document', add the doc.cheap API from the directory, and store your bearer token once. Your agent then submits the document and reads the extracted contents from the scan result. To run it on your own infrastructure, install Jentic One from its GitHub repo.