If you’ve ever built an integration against Odoo’s document extraction API, you know the routine. You grab the integration token, send a test document, and get back a response that looks plausible but is entirely fabricated. The system never actually read your document. It returned canned data — the same hard-coded fields every time, regardless of what you uploaded. Your invoice, your receipt, your purchase order — none of it mattered. The response was a script, not a scan.
That era is over. Odoo has reworked how its extraction API handles the integration token, and the change fundamentally alters what “testing” means for developers building on the platform.
How the Old Test Mode Actually Worked
The previous behavior was straightforward in its limitations. When a developer used the integration token — the credential Odoo provides for testing purposes — the system entered a fully simulated mode. You could call the API endpoints, send documents, and poll for results, and everything appeared to function correctly. The HTTP status codes were right. The JSON structure matched the production schema. The response times felt realistic.
But the document you uploaded was never processed. The OCR engine never touched it. Instead, the result endpoint returned a pre-built response with static values. Every test returned the same vendor name, the same line items, the same totals. It was a stage prop — convincing from a distance, hollow up close.
For basic connectivity testing, this was adequate. You could verify that your code correctly called the endpoints, handled authentication, and parsed the response format. But for anything beyond that — validating that your field mapping logic handled real-world OCR quirks, testing edge cases with multi-page documents, or checking whether your error handling dealt with partially extracted data — the simulated mode was useless. You were testing your integration against fiction.
What Changes With the New Approach
The integration token now triggers actual document processing. When you send a PDF or image to the extraction API using the test credential, Odoo’s OCR engine processes it for real. The system reads the document, extracts text, identifies fields, and returns genuine parsed data specific to the file you uploaded. No more canned responses. No more one-size-fits-all output.
The critical difference is that this real processing comes without billing. The integration token remains a free testing credential. You are not charged for documents parsed through it. This preserves the original intent — letting developers test without financial commitment — while dramatically improving the quality of what those tests can verify.
There is, however, a guardrail. The integration token now carries strict daily rate limits. Odoo caps the number of documents you can process in a 24-hour window, and if you hit that ceiling, you wait until the next day for the limit to reset. There is no way to pay for additional test capacity or request a temporary increase. The rate limit is the boundary between testing and production, and Odoo enforces it firmly.
Why Mocked Responses Were a Problem
The old approach created a false confidence trap. Developers would build their integration, run it against the simulated endpoint, see green checkmarks across their test suite, and deploy to production feeling assured. Then reality hit. Real invoices from real vendors came back with fields in unexpected positions. Currency symbols confused the parser. Handwritten notes on a scanned document bled into adjacent fields. None of these scenarios surfaced during testing because the test environment never parsed a real document.
The gap between simulated and actual behavior was especially painful for teams building automated accounting workflows. An integration that looked flawless in test mode would start generating incorrect journal entries in production because the OCR output had confidence scores, partial matches, and ambiguous field boundaries that the hard-coded test data never exhibited.
What Developers Should Expect Now
With real parsing in test mode, the feedback loop tightens considerably. Upload a sample invoice and you get back the actual extracted data — complete with confidence scores, bounding box coordinates, and the occasional misread character that mirrors what production traffic looks like. This means you can now write meaningful validation logic during development. You can test how your system handles low-confidence extractions. You can verify that your mapping between OCR output and your internal data model survives contact with messy, real-world documents.
The daily rate limit is the main constraint to plan around. For most integration development, the cap should be sufficient — you are testing a handful of representative documents, not running bulk processing. But teams that relied on the old unlimited-but-fake approach for load testing or continuous integration pipelines will need to rethink their strategy. The test token is no longer suited for high-volume automated test runs, because each call now consumes a real parsing operation against the daily quota.
The Broader Shift Toward Honest Testing
This change reflects a broader principle gaining traction in API design: test environments should behave like production environments, just with guardrails. The old pattern of returning fabricated data in test mode was a shortcut that saved compute resources but shifted the risk onto developers. Every integration that passed testing but failed in production was, in part, a failure of the test environment to represent reality.
By switching to real parsing with rate limits, Odoo strikes a balance. Developers get authentic output without paying for it. Odoo controls cost exposure through daily caps. And integrations that pass testing now have a much higher probability of working correctly when the production token is activated and billing begins.
For teams currently building or maintaining Odoo document extraction integrations, the action items are clear. Update your test documents to include representative samples of what you’ll process in production. Adjust your CI pipeline to respect the daily rate limit. And rewrite any assertions in your test suite that depended on the old hard-coded response values — those specific values no longer exist. What comes back now is real data, and real data has a habit of being less predictable and more useful than anything a simulation could offer.