For developers
Document extraction for developers who need an exit route
Treat document AI as a replaceable processing step, not a model vendor baked into the rest of your application.
A document pipeline has more than one contract. Files enter, a model proposes structure, reviewers correct the result and another system consumes the approved data. Keeping those boundaries explicit makes failures easier to retry and providers easier to change.
Dynamite Docs exposes scoped API tokens, versioned extraction endpoints, JSON exports and signed completion webhooks. The same workspace can use hosted models, provider keys connected by the account owner or a custom OpenAI-compatible endpoint. Review and export stay consistent when the model route changes.
Test the extraction shape. Start in the browser, then create a scoped token when the response fits the job.
Decision register
- Auth: Scoped bearer or X-API-Key token
- Output: Structured fields, rows and metadata
- Events: HMAC-signed completion webhooks
- Models: Hosted, BYOK, custom or local
Built for software that already owns the business process
Use Dynamite Docs to read and review documents while your application keeps ownership of users, approvals and downstream records.
Invoice and document ingestion
Accept PDFs or images, infer a schema and return fields and repeating rows without supplier coordinate templates.
Human review before side effects
Keep document correction separate from the code that posts records, sends messages or changes a system of record.
Provider portability
Move between supported providers or a custom compatible endpoint without rewriting the review and export interface.
Event-driven handoff
Receive a signed completion event, fetch the reviewed result and handle retries in the application that owns the workflow.
The integration contract developers should evaluate
Model accuracy matters, but a production integration also needs explicit authentication, limits, failures and data ownership.
| Concern | Dynamite Docs contract | Application responsibility |
|---|
| Authentication | Hashed, scoped API tokens shown once | Store secrets outside source control and rotate them |
| Extraction | Structured fields, rows, document type and metadata | Validate required fields for the business action |
| Completion | HMAC-signed webhook with bounded retries | Verify the signature and make the consumer idempotent |
| Rate limits | Per-key request limit plus monthly plan allowance | Back off on 429 and expose a recoverable state |
| Provider route | Hosted, account BYOK, custom endpoint or local companion | Select a policy and test representative files |
| Exports | JSON, CSV, XLSX, Sheets and Drive | Map the reviewed schema to the destination contract |
| Revocation | Deactivate the stored token hash | Replace the secret in every dependent service |
A safer integration sequence
- 1. Define the output contract. Write the required fields, row shape, data types and failure behavior before selecting a model.
- 2. Test representative files. Include clean PDFs, scans, multi-page tables and the layouts that fail in the current process.
- 3. Keep review before posting. Treat the extracted result as proposed data until the required checks and approvals pass.
- 4. Instrument errors and limits. Record response status, usage headers, webhook attempts and downstream validation failures.
Keep the model behind a stable document contract
Provider accounts change, model names move and one model can be better for a certain document type. Dynamite Docs discovers models from connected provider accounts and keeps the extracted result in the same fields-and-rows shape.
Pro and Ultra can use unlimited own-key processing without spending hosted PE. A custom OpenAI-compatible endpoint provides another route. The local companion is useful when model inference should run on the user computer, but it does not self-host the account or workspace service.
- Hosted API: Use the platform route and account PE allowance.
- Provider account: Connect an encrypted key and use models available to that account.
- Compatible endpoint: Supply an API key and base URL for a supported custom route.
- Local companion: Call Ollama over an authenticated loopback service.
Compare hosted, own-key, custom and local AI routes.
What still belongs in your application
The extraction service should not silently become the system of record. Keep business-side effects under the application that already owns them.
- Validate required fields and types before creating records.
- Make webhook consumers idempotent and resilient to repeated delivery.
- Store approvals, posting status and reconciliation state in the owning application.
- Plan for unavailable providers, unreadable files, exhausted limits and human correction.
Questions about for developers
Can I submit invoices through the API?
Yes. Use a scoped token to submit supported document files and retrieve structured extraction data. Review the current API chapter for request and response details.
Can my application choose any model?
The available model depends on the hosted configuration or connected provider account. The registry discovers current provider models and applies capability and policy checks before use.
Are webhook events signed?
Yes. Outbound events include an HMAC-SHA256 signature. Verify the signature and reject stale or replayed requests according to your integration policy.
Is the local companion a self-hosted API?
It is a signed loopback service for local model inference. Authentication, account state, workspace data and token issuance remain part of the hosted product.
Continue with the exact document task
Test the extraction shape or compare processing, storage and integration limits.