Schema-constrained OCR extracts document values into a supplied JSON Schema. For clinical data ingestion and claims processing, you need both correct fields and a valid output structure. In John Snow Labs’ 100-document OmniOCR evaluation, GPT-5.2 led with 0.888 json-diff accuracy. The article reports 0.730 for JSL Vision Structured-8B, the highest score among its self-hosted models. Evaluate extraction accuracy and output validity separately when selecting your pipeline.
This third benchmark follows our grounded OCR comparison, which evaluates text and coordinates, and our plain-text OCR comparison, which evaluates full-page transcription.
The prose and published charts contain different result sets: the prose reports 0.730 for JSL Vision Structured-8B, while the summary and leaderboard graphics show 0.714. The leaderboard graphic contains 19 models. The sections below identify these differences rather than combining the values into one result.

Published summary graphic. It shows 0.714 for JSL Vision Structured, while the prose reports 0.730. Its “100% valid JSON guaranteed” card describes a structural decoding claim, not a measured guarantee that every request succeeds.
How does schema-constrained OCR produce structured records?
You supply a document image and a JSON Schema defining the required fields and types. The model extracts values from the image into that structure.

Schema-constrained extraction takes a document image and a supplied schema as inputs. The example illustrates the output format; extracted values still require validation.
You can then validate the extracted fields before mapping them into clinical records, claims systems, or research databases. A schema-valid response still needs checks for missing or incorrect values.
What should you validate before importing extracted fields?
Clinical document pipelines populate specific fields: lab measurements in an EHR, procedure codes in a claim, or timestamps in a case report form. Text recognition is one part of that task.
Check whether the response parses as JSON, conforms to the supplied schema, and contains the correct values. Route invalid or incomplete results to a retry or review step before importing them into your downstream system.
Which models led the JSON extraction evaluation?

Self-hosted model comparison as shown in the published graphic. The prose separately reports JSL Vision Structured-8B at 0.730 and an additional olmOCR-7B result at 0.714.
GPT-5.2 recorded 0.888 json-diff accuracy, followed by Gemini 2.5 Flash at 0.873, Gemini 2.5 Pro at 0.840, and Claude Opus 4.5 at 0.800. Claude Sonnet 4.5 scored 0.709.
The article’s prose places JSL Vision Structured-8B fifth at 0.730 and lists olmOCR-7B at 0.714. The published podium and leaderboard instead show JSL Vision Structured at 0.714; the leaderboard does not include a separate olmOCR-7B row. These are different published result sets.
JSL Vision-30B scores 0.689 in both the prose and leaderboard, where it is seventh. GPT-5.2’s 0.271 character error rate on the separate plain-text benchmark shows why you should evaluate transcription and schema-based extraction as distinct tasks.
How do the 19 charted models compare?

Published 19-model OmniOCR leaderboard; higher json-diff accuracy is better. The HTML table reproduces these chart values, while the prose identifies its separately reported results.
| Chart rank | Model label in published chart | Json-diff accuracy ↑ |
|---|---|---|
| 1 | GPT-5.2 | 0.888 |
| 2 | Gemini 2.5 Flash | 0.873 |
| 3 | Gemini 2.5 Pro | 0.840 |
| 4 | Claude Opus 4.5 | 0.800 |
| 5 | JSL Vision Structured | 0.714 |
| 6 | Claude Sonnet 4.5 | 0.709 |
| 7 | JSL Vision | 0.689 |
| 8 | Holo2-30B-A3B | 0.684 |
| 9 | Qwen3-VL-8B | 0.676 |
| 10 | Pixtral-Large | 0.670 |
| 11 | Llama-4-Maverick | 0.668 |
| 12 | Nanonets-OCR2-3B | 0.593 |
| 13 | OCRFlux-3B | 0.496 |
| 14 | Qwen3-VL-235B | 0.488 |
| 15 | Phi-4-Multimodal | 0.383 |
| 16 | JSL Vision OCR (no schema decoding) | 0.342 |
| 17 | Grok-4 | 0.255 |
| 18 | Sonar Pro | 0.134 |
| 19 | PaddleOCR-VL | 0.033 |
Higher json-diff accuracy is better. This table reproduces the published 19-row leaderboard. The prose separately reports JSL Vision Structured-8B at 0.730 and olmOCR-7B at 0.714; that additional olmOCR row is absent from the chart.
Grok-4 scored 0.255 and Sonar Pro 0.134 in this evaluation. PaddleOCR-VL scored 0.033, with 50 empty predictions out of 100 documents. These results describe the tested extraction setup, rather than every deployment of those models.
How much does schema-constrained OCR cost?
Compare extraction accuracy with cost for your expected document volume. The following figures are the article’s historical estimates per 1,000 documents, rather than current API prices.

Published cost estimates per 1,000 documents plotted against json-diff accuracy. JSL chart points differ from the prose estimates; compare hardware and serving configurations before using either for budgeting.
GPT-5.2 is listed at approximately $15.58 per 1,000 documents and 0.888 accuracy. Gemini 2.5 Flash is listed at approximately $2.75 and 0.873. The prose estimates approximately $6.76 on H100 for each JSL configuration, with an approximately $1.50 A10G estimate for JSL Vision Structured-8B. Grok-4 is listed at $86.70 and 0.255 accuracy.
The scatterplot shows different JSL cost points and uses 0.714 for JSL Vision Structured. Read those points as the chart’s published estimates; they do not establish the same hardware configuration or timing basis as the prose. Recalculate costs using your document lengths, inference settings, and infrastructure rates.
How long does JSON extraction take per document?
The published latency chart contains 18 models. It combines local H100 inference timings with API response timings, so compare the hardware and serving setup alongside each value.

Published JSON-extraction latency chart. Local values are labeled H100 inference; API values include service response time. The prose separately reports 9.7 seconds for JSL Vision and approximately 3–4 seconds on A10G for JSL Vision Structured.
The chart shows JSL Vision OCR at 1.8 seconds per document and JSL Vision Structured at 3.5 seconds. The prose separately gives 9.7 seconds for JSL Vision and approximately 3–4 seconds on A10G for JSL Vision Structured. It reports Gemini 2.5 Pro at 50 seconds and rounds Grok-4 to 94 seconds, versus 93.5 seconds in the chart. These published timings should not be combined into a single configuration or a universal speed ranking.
How often did extraction return an empty prediction?
Track empty predictions separately from average extraction accuracy. A missing result needs an explicit retry, fallback, or review path before downstream ingestion.

Empty-prediction counts for four published configurations. JSL Vision Structured has 1 empty result out of 100 in this chart; structured decoding does not eliminate every request failure.
The published failure chart shows 1 empty prediction out of 100 for JSL Vision Structured, 6 for Claude Opus 4.5, 18 for JSL Vision OCR without schema decoding, and 50 for PaddleOCR-VL. The chart compares these four configurations; it does not establish the failure rate of every model in the leaderboard.
Schema-aware decoding constrains output structure. It does not prevent every empty response, interrupted request, or incorrect field value.
What does schema-aware decoding enforce during generation?
The evaluation prompted API models with an image, a schema, and an instruction to return JSON. Local models used structured generation where supported. This compares the tested pipelines, including their decoding settings; it does not compare every provider’s native structured-output mode.
In vLLM structured generation, a backend such as xgrammar constrains generation to a supported output schema. Verify schema support and validate completed responses in your application. Structural constraints do not establish that extracted values are correct or that outputs will be identical across hardware, versions, and deployments.
What should you check before deploying clinical extraction?
For clinical ingestion, evaluate field accuracy and schema validity alongside failure handling. Keep the source document, extracted result, validation status, and model configuration available for review.
Self-hosted inference lets you process documents within your environment. Configure access controls, logging, and retention for your deployment; on-premises inference alone does not establish HIPAA or GDPR compliance or SOC 2 assurance.
The article lists single-GPU options and historical cost estimates of approximately $1.50 per 1,000 documents on A10G and $6.76 on H100 for the 30B model. Size your deployment using measurements from the model, task, and serving configuration you intend to run.
How was schema-constrained OCR evaluated on OmniOCR?
- Dataset: the OmniAI OCR benchmark, using the article’s stated 100-document test split.
- Metric: json-diff accuracy against reference JSON, with deep-sorted keys and case-insensitive values. This is an extraction score, separate from a JSON parsing or schema-validation pass rate.
- API configuration: OpenRouter requests at temperature 0 and max_tokens 8192, with the schema in the prompt.
- Local configuration: vLLM v0.17.1 on NVIDIA H100, f16 precision, with structured generation where supported.
- Parsing: strip Markdown fences; if parsing fails, attempt extraction from the first opening brace to the last closing brace.
- Empty predictions: count separately and include in the average with a score of 0.
Per-document outputs are archived internally. The published prose and charts differ in some scores, model lists, and timing estimates; their specific values are identified alongside the relevant comparisons above.
What do the separate GPU and CPU tests show?
The following charts compare H100 GPU and CPU inference on the same 5 FUNSD pages. The charts label GPU precision as bfloat16 and CPU precision as float32. Compare these hardware results separately from the 100-document OmniOCR JSON evaluation.

GPU runs are labeled bfloat16 and CPU runs float32. Account for precision when comparing the hardware results.
In this hardware comparison, JSL Vision Structured takes 10.4 seconds per page on GPU and 74.8 seconds on CPU, a 7.2× speedup.

Compute estimates for the separate hardware test, using $2.50 per H100 hour and $0.34 per CPU hour. The JSL Vision Structured estimates are approximately 2% apart; this does not establish JSON extraction cost.
At the chart’s hourly rates of $2.50 for H100 and $0.34 for CPU, JSL Vision Structured costs $7.22 and $7.07 per 1,000 documents respectively, approximately 2% apart. This estimate covers the chart’s measured inference workload; it does not establish the cost of schema-constrained JSON extraction. The A10G estimate elsewhere in the article is separate from these measurements.

Memory usage in the separate hardware comparison. GPU and CPU runs use different precision; these values are not memory measurements for the 100-document OmniOCR JSON evaluation.
The memory chart compares bfloat16 GPU usage with float32 CPU usage. Account for precision and serving backend when sizing your deployment, then measure latency and memory with your own JSON schemas and representative clinical documents.
Which OCR benchmark fits your document pipeline?
Choose an evaluation that matches the output you need:
- Grounded OCR on FUNSD evaluates recognized text with bounding-box coordinates.
- Plain-text OCR on FUNSD evaluates full-page transcription for search and downstream text processing.
- This schema-constrained OCR comparison evaluates extraction into a supplied JSON Schema on OmniOCR.
GPT-5.2 led the JSON evaluation at 0.888. JSL Vision Structured had the highest self-hosted score in the published comparison, with 0.730 reported in the prose and 0.714 shown in the chart. For your deployment, assess field accuracy and output validation together, then measure the cost of handling failures.
Schedule a demo to evaluate JSL Vision Structured with your document types and schemas.
Frequently asked questions about schema-constrained OCR
What is schema-constrained OCR?
Schema-constrained OCR extracts values from a document image into a supplied JSON Schema. You define the fields and types, then validate the model’s output before downstream ingestion.
Does valid JSON mean the extracted values are correct?
No. A response can satisfy its schema while containing an incorrect value or missing information from the source document. Evaluate extraction accuracy separately from parsing and schema validity.
Which model scored highest in this evaluation?
GPT-5.2 led at 0.888 json-diff accuracy. JSL Vision Structured led the self-hosted comparison, with 0.730 in the article’s prose and 0.714 in its published chart.
Did schema-aware decoding eliminate every empty prediction?
No. The published failure chart shows 1 empty prediction out of 100 for JSL Vision Structured. Keep an explicit fallback or review path for missing and invalid results.
Do the CPU and GPU charts measure JSON extraction?
The hardware charts label a separate comparison on 5 FUNSD pages. Use those results as hardware context, then benchmark schema-constrained extraction on representative documents and schemas.
Does self-hosting establish compliance for clinical documents?
Self-hosting lets you process documents within your environment. Your deployment still needs appropriate access controls, logging, retention policies, and review against its applicable requirements.





























