Extract documents with LLM models using your own API keys
Dynamite Docs- Google Gemini
- Use models returned by the connected Google account and check vision support.
- Groq Cloud
- Use models returned by the connected Groq account and its current limits.
Bring your own key to any of these providers
Compare hosted, own-key, and local processing
The review workspace stays consistent, but account ownership, credentials, provider terms, model availability, and PE treatment differ by route. Check those differences before processing a sensitive document or scheduling a batch.
Hosted processing
Dynamite Docs manages model discovery and routing. Extractions draw directly from your plan allowance.
Own provider key
Bring verified keys from Google, Groq, Mistral, OpenAI, Anthropic, or custom gateways. AES-256-GCM encrypted.
Local companion
Inference stays on your physical machine via authenticated loopback on port 8756. Zero external data transmission.
| Dimension | |||
|---|---|---|---|
| Model account | Managed by Dynamite Docs | Your verified provider account | Your local Ollama installation |
| Request route | Eligible hosted provider | Provider endpoint for the selected key | Signed loopback connection on port 8756 |
| Credentials | No provider key to configure | Key encrypted with AES-256-GCM | Signed local token required for every route |
| Model availability | Discovered by the hosted router | Discovered from the connected account | Models installed in local Ollama |
| Plan accounting | Successful pages use hosted PE | Free and Starter use PE; Pro and Scale cost 0 PE | Eligibility and usage appear in the workspace |
| Review and export | Source beside proposed fields and rows | Same source-first review workspace | Same source-first review workspace |
Provider billing, limits, and data handling
The provider account, model availability, API limits, and provider charges remain under your control.
Scans and photos need a vision-capable model. A text-only model cannot inspect the pixels on an image-only page.
Provider retention, training, and regional terms differ. Check the selected route before sending a sensitive document.
A model can return an incomplete or incorrect value. The source-first review and export steps stay the same whichever route you select.
How BYOK document extraction works inside Dynamite Docs
Connect your API key in settings
Open Settings > AI & Processing in your workspace. Choose your provider from Google Gemini, Groq, Mistral, OpenAI, Anthropic, OpenRouter, or Custom Endpoint. Paste your secret key and click Verify & Save Key. The server runs an instant health check to discover available models and encrypts the key at rest using AES-256-GCM.
Configure active models and fallback routing
Choose from the models discovered for the verified key. If you configure a fallback, make sure it also supports the document type and satisfies the same privacy policy. A fallback reduces dependency on one route but does not guarantee availability.
Set data privacy and residency policies
Use the policy controls to exclude routes that do not meet the active training or residency rule. When cloud transmission is not acceptable, use the signed local Ollama companion on an eligible plan.
Extract, review, and export
Upload a supported document and run it with the selected route. Compare proposed fields and rows with the source before export. Free and Starter own-key pages use the monthly PE allowance; Pro and Scale own-key runs cost 0 PE. Provider charges and limits still apply.
How to connect your AI provider inside Dynamite Docs
Follow these step-by-step instructions to generate your API keys, connect credentials in Settings > AI & Processing, and configure active vision models for automated extraction.
Google AI Studio (Gemini)
Wholesale: ~$0.0002 / pageGoogle AI Studio gives developers direct access to Gemini 2.0 Flash and 1.5 Pro. It delivers sub-second extraction on invoices and receipts, plus a 2,000,000 token context window that parses 150-page statement batches in a single prompt without row loss across page boundaries.
Connection instructions inside Dynamite Docs
Generate key in Google AI Studio
Sign in at aistudio.google.com/app/apikey with your Google profile, click "Create API key", and link to an existing Google Cloud project with billing enabled or initialize a new project.
Navigate to AI Settings in Dynamite Docs
In your Dynamite Docs workspace, open Settings > AI & Processing (/app). Choose "Google Gemini" from the provider catalog dropdown.
Paste key and run verification
Paste your AIzaSy... key and click "Verify & Save Key". The server performs an encrypted validation ping to ensure your token is active and discovers available models.
Set active and fallback models
Select gemini-2.0-flash as your primary model for high-velocity intake. Configure gemini-1.5-pro for complex multi-page financial statements.
Dynamite Docs- 01Connect your API key in settings
- 02Configure active models and fallback routing
- 03Set data privacy and residency policies
- 04Extract, review, and export
Supported providers, endpoints, and architectural controls
The available model list is discovered from each verified account. Provider keys are encrypted with AES-256-GCM before storage:
24 supported providers
Model
15Router
1Local
1Self-host
1Plus any OpenAI-compatible endpoint: a custom base URL and model id route straight to your own gateway. Keys are encrypted with AES-256-GCM and used only to route your own requests.
A realistic example
Dynamite Docs- Google Gemini
- Use models returned by the connected Google account and check vision support.
- Groq Cloud
- Use models returned by the connected Groq account and its current limits.
- Mistral AI
- Use models returned by the connected Mistral account and its regional terms.
Possible routes for a mixed batch of accounting documents:
Developer API and cURL integration
Connect provider keys and execute extractions programmatically. Automated endpoints authenticate with your scoped API token and route requests through your connected models.
Verify and store an encrypted provider key
Connect an external API key. The server validates credentials against the provider API, discovers available models, and saves the secret encrypted with AES-256-GCM.
curl -X POST \
-H "Authorization: Bearer <clerk_token>" \
-H "Content-Type: application/json" \
-d '{
"provider": "groq",
"apiKey": "gsk_a8b9c0d1e2f3...",
"preferredModel": "<discovered_model_id>"
}' \
"https://app.dynamitedocs.com/api/ai/keys"{
"success": true,
"provider": "groq",
"status": "connected",
"discoveredModels": [
"<discovered_model_id>",
"<another_available_model_id>"
],
"activeModel": "<discovered_model_id>",
"verifiedAt": "2026-09-15T15:00:00.000Z"
}Model-agnostic human review and reconciliation
Test the output again when you change models
A different model can return different fields, column names, or values. Dynamite Docs keeps the source, editable result, confidence cues, and export controls in the same workspace, so the reviewer can compare the first result from a new route before it reaches a spreadsheet or downstream system.
Inline Document Correction
Inspect bounding boxes and override values directly beside the original source before export.
Pattern Memory & Field Learning
User corrections are remembered for the document pattern so subsequent runs inherit the corrected schema.
$0
markup on inference
With your own key you pay your provider's published rate. We never add a reseller margin to a BYOK request.
Unlimited
BYOK on Pro and Scale
Own-key processing never counts against the hosted monthly allowance. You pay the provider directly.
24
auto-registered providers
Discovered live at startup, not hardcoded. Plus any OpenAI-compatible endpoint and a local Ollama companion.
What provider routing does and does not do
Zero-Training Guarantee
Sensitive mode blocks non-compliant routes. Inputs are never retained for model weights.
AES-256-GCM Encryption
Credentials are encrypted before disk write and never exposed or leaked in logs.
Data Residency & Local
Enforce EU data sovereignty or switch to local Ollama on loopback port 8756.
Does
- Sends an authenticated extraction request to the hosted, own-key, custom, or local route you select.
- Encrypts stored provider keys with AES-256-GCM.
- Discovers the models currently available to a verified provider account.
- Applies configured provider-policy and fallback rules before an eligible request is routed.
- Supports model inference through the signed local Ollama companion on an eligible plan.
Does not
- Does not control a provider's prices, model availability, rate limits, or account terms.
- Does not make a text-only model capable of reading an image-only document.
- Does not guarantee that a fallback route is available or policy-compatible.
- Does not make a model response correct without source review.
- Does not bypass Free or Starter PE limits when you use your own key.
Keep the review contract stable when the model changes
Provider models and account limits change. The useful constant is the workflow around them: a supported source file, proposed fields and rows, source review, corrections, and an explicit export.
Changing the model does not prove that its output matches the last model. Keep required columns and validation checks in the workspace, then compare high-risk values with the source before delivery.
Choose a hosted, own-key, custom, or local route according to the document type, provider terms, and the controls your organization requires.
Use Your Own API Key for AI Document Extraction
Follow the connection steps for supported provider accounts and local Ollama. The guide also covers model discovery, policy checks, rate limits, source review, and a representative test before a batch run.
Questions, answered
Sign in to your provider developer console: Google AI Studio (aistudio.google.com/app/apikey), Groq Cloud (console.groq.com/keys), Mistral AI (console.mistral.ai/api-keys), OpenAI Platform (platform.openai.com/api-keys), or Anthropic (console.anthropic.com/settings/keys). Create a new secret key, copy the token, navigate to Settings > AI & Processing in Dynamite Docs, and click Verify & Save Key.
Free and Starter own-key pages draw from the monthly PE allowance. Pro and Scale own-key runs cost 0 PE, though provider charges, file-size limits, and provider limits still apply.
Provider handling depends on the provider, product, account, and current terms you use. Check those terms before processing a sensitive invoice. Dynamite Docs can block routes that do not meet an active no-training policy, and eligible plans can use the local Ollama companion instead of an external model API.
The provider bills its own API usage at the rates attached to your account. Dynamite Docs applies the PE treatment of your plan. Check both the provider dashboard and the Dynamite Docs usage ledger when estimating a batch.
The route can expose quota signals and use an eligible configured fallback. A fallback must support the document and satisfy the active provider policy. If no eligible route is available, the extraction can fail and should be retried after the provider limit clears.
On Starter, Pro, and Scale, the [local Ollama companion](/local-ai-document-parser-on-windows) can run model inference on your workstation through an authenticated loopback connection on port 8756. Use browser-only file storage with that route when the document must not be sent to an external model provider.
They can if the requested schema or reviewed pattern does not constrain them. Compare the result after a model change, keep required columns explicit, and validate the final JSON or spreadsheet before a downstream import.
A vision-capable model can attempt those files, but blur, glare, skew, fading, and handwriting increase error risk. Use the original image when possible and compare merchant, date, tax, total, and line items with the source.
Related integrations
Document workflows it feeds
From the blog
Your key, your model, your rate
Connect a provider and test one representative document.
Open Settings > AI & Processing, verify the key, choose a discovered model, and compare the first extraction with the source before using that route for a batch.