← All cheap-model tests
Structured Data · Models under $3/M tokens · Jun 16, 2026

Extracting Structured Data: Which Cheap AI Model Wins?

A structured-output task: read one sentence and return strict JSON with a string name, numeric price, and boolean stock flag — no markdown, no prose. We sent this exact task to all 19 budget models (each under $3 per million output tokens) through the live API and measured real speed, cost, and accuracy. The full output of every model is included below — click any row to read it.

Most accurate
GPT-5.4 Nano
100/100 · OpenAI
Fastest
GLM 4.7 (Cerebras)
562.9 t/s · 723 ms
Cheapest run
Amazon Nova Micro
$0.0000074

The prompt

Every model received exactly this, with default generation settings:

Extract the product details from the following sentence and return ONLY a valid JSON object with exactly these keys: "name" (string), "price" (number), "in_stock" (boolean). Do not include any explanation or markdown. Sentence: "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship."

How accuracy was graded

  • Output is valid, parseable JSON.
  • Extracts the full product name ("DeskPro X1 monitor stand").
  • Correct types: price as a number (49.99), in_stock as a boolean (true).
  • Returns only the JSON — no markdown fences, prose, or leaked reasoning.

Results — sortable by speed, cost & accuracy

Click Accuracy, Speed, or Cost to re-sort. Click any row to read the full model output.
Per-model results: accuracy, speed (tokens/sec), provider cost (USD), and the full prompt-vs-output for each model on this task.
#ModelAccuracy Speed Cost Output
Agent grade — 100/100. Perfect: compact valid JSON, full product name, correct number and boolean types, no markdown or prose.
Verbatim output (78 in / 24 out tokens, 488 ms, $0.0000456)
{"name":"DeskPro X1 monitor stand","price":49.99,"in_stock":true}
Agent grade — 99/100. Valid JSON, full name, correct types, no markdown — just pretty-printed rather than compact.
Verbatim output (75 in / 36 out tokens, 477 ms, $0.0000727)
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
Agent grade — 99/100. Valid compact JSON, full name, correct types, no markdown or prose. Fastest run in this test.
Verbatim output (107 in / 26 out tokens, 172 ms, $0.0000837)
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 99/100. Valid compact JSON, full name, correct types, no markdown — and the cheapest run here.
Verbatim output (107 in / 26 out tokens, 296 ms, $0.0000074)
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 99/100. Valid compact JSON, full name, correct types, no markdown or leakage.
Verbatim output (91 in / 29 out tokens, 808 ms, $0.0000944)
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 99/100. Valid compact JSON, full name, correct types — identical quality to Medium for far less.
Verbatim output (91 in / 29 out tokens, 530 ms, $0.000031)
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 99/100. Valid compact JSON, full name, correct types, no markdown or prose.
Verbatim output (79 in / 29 out tokens, 470 ms, $0.0000498)
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 99/100. Valid JSON, full name, correct types, no markdown or prose — only pretty-printed rather than compact.
Verbatim output (76 in / 34 out tokens, 380 ms, $0.0000074)
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
Agent grade — 85/100. Correct values and full name, but wrapped the JSON in a ```json markdown fence after being told "no markdown".
Verbatim output (82 in / 35 out tokens, 350 ms, $0.0000209)
```json
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
```
Agent grade — 85/100. Correct values and full name, but wrapped the output in a ```json markdown fence against instructions.
Verbatim output (79 in / 38 out tokens, 599 ms, $0.0000175)
```json
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
```
Agent grade — 85/100. Correct values and full name, but wrapped the JSON in a ```json markdown fence after being told "no markdown".
Verbatim output (76 in / 38 out tokens, 340 ms, $0.0000137)
```json
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
```
Agent grade — 82/100. Correct JSON with full name and proper types; docked only for the leaked <think> preamble.
Verbatim output (79 in / 123 out tokens, 2033 ms, $0.0000455)
<think>
We need to extract product details: name, price (number), in_stock. Sentence: "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship."

Name: "DeskPro X1 monitor stand" (should be string)
Price: $49.99 -> 49.99 as number
In_stock: "currently available to ship" implies it's in stock, so true.

Return JSON only.
</think>
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 82/100. Correct, complete JSON; the leaked <think> block is the only issue.
Verbatim output (79 in / 179 out tokens, 2104 ms, $0.00019)
<think>
We are asked to extract product details from the sentence: "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship."

We need to return ONLY a valid JSON object with keys: "name" (string), "price" (number), "in_stock" (boolean).

From the sentence:
- Name: "DeskPro X1 monitor stand"
- Price: $49.99 -> number 49.99
- In stock: "currently available to ship" implies it is in stock, so true.

So JSON: {"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}

Make sure no extra text.
</think>
{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 80/100. Valid JSON with the full name and correct types, but a leaked <think> block violates "return ONLY a valid JSON object".
Verbatim output (81 in / 74 out tokens, 2819 ms, $0.000286)
<think>
The task is: Extract the product details from the sentence and return ONLY a valid JSON object with exactly these keys: "name" (string), "price" (number), "in_stock" (boolean). Do not include any expl...
</think>
{
"name": "DeskPro X1 monitor stand",
"price": 49.99,
"in_stock": true
}
Agent grade — 80/100. Final JSON is correct and complete, but a <think> block leaked in despite the "no explanation" instruction.
Verbatim output (143 in / 81 out tokens, 277 ms, $0.00007)
<think>
We need to output JSON with keys name, price, in_stock. Extract details: name: "DeskPro X1 monitor stand". price: 49.99. in_stock: true (available to ship). Return only JSON, no markdown.
</think>
{"name":"DeskPro X1 monitor stand","price":49.99,"in_stock":true}
Agent grade — 80/100. Correct JSON with the full name, but preceded by a leaked <think> reasoning block.
Verbatim output (143 in / 164 out tokens, 343 ms, $0.0000599)
<think>
The user wants to extract product details: name: "DeskPro X1 monitor stand", price: 49.99, in_stock: true. The sentence: "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship." The name: "DeskPro X1 monitor stand". Price: 49.99. In_stock: currently available to ship => in stock: true. JSON with keys: name, price, in_stock.

Return only JSON object, no explanation, no markdown. So just:

{"name":"DeskPro X1 monitor stand","price":49.99,"in_stock":true}
</think>
{"name":"DeskPro X1 monitor stand","price":49.99,"in_stock":true}
Agent grade — 75/100. Final JSON is correct, but buried under a ~340-token leaked <think> monologue — the opposite of "JSON only".
Verbatim output (82 in / 336 out tokens, 784 ms, $0.000222)
<think>
Okay, let me try to figure this out. The user wants me to extract product details from a sentence and put them into aJSON object with specific keys: name, price, and in_stock. The sentence given is "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship." 

First, I need to identify the product name. The sentence starts with "The DeskPro X1 monitor stand..." so the name is probably "DeskPro X1 monitor stand". I should check if there's any other part of the name, but "DeskPro X1" seems like the model, and "monitor stand" is the product type. So the name key should be that full phrase.

Next, the price is mentioned as "$49.99". The key requires a number, so I need to remove the dollar sign and convert it to a numerical value. That would be 49.99. 

For the in_stock boolean, the sentence says "is currently available to ship". If it's available to ship, that likely means it's in stock. So in_stock should be true. 

I need to make sure there are only those three keys and that the JSON is valid. Let me double-check each part. The name is correct, price is a number without the currency symbol, and in_stock is a boolean. No other keys are needed. Alright, putting that all together into a JSON object with the exact keys.
</think>

{"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
Agent grade — 73/100. The final JSON is correct, but the model exposed a ~400-token multi-step <think> process despite "no explanation".
Verbatim output (77 in / 407 out tokens, 723 ms, $0.001292)
<think>
1.  **Analyze the Request:**
    *   Input sentence: "The DeskPro X1 monitor stand normally retails for $49.99 and is currently available to ship."
    *   Task: Extract product details.
    *   Output format: Valid JSON object only.
    *   Required keys: "name" (string), "price" (number), "in_stock" (boolean).
    *   Constraint: No explanation, no markdown code blocks (just the raw JSON).

2.  **Analyze the Sentence to Extract Data:**
    *   *Name:* "The DeskPro X1 monitor stand". I should probably clean this up slightly to just the product name, or keep it as is. "DeskPro X1 monitor stand" seems most appropriate. Let's stick to the core product name.
    *   *Price:* "$49.99". The key requires a number. So, 49.99.
    *   *Stock Status:* "currently available to ship". This implies it is in stock. So, true.

3.  **Construct the JSON Object:**
    *   `name`: "DeskPro X1 monitor stand"
    *   `price`: 49.99
    *   `in_stock`: true

4.  **Verify against Constraints:**
    *   Valid JSON? Yes.
    *   Keys present? "name", "price", "in_stock". Yes.
    *   Types correct? String, Number, Boolean. Yes.
    *   No explanation? Yes.
    *   No markdown? Yes (I need to ensure I don't wrap it in backticks).

5.  **Final Output Generation:**
    {"name": "DeskPro X1 monitor stand", "price": 49.99, "in_stock": true}
</think>
{
  "name": "DeskPro X1 monitor stand",
  "price": 49.99,
  "in_stock": true
}
Agent grade — 72/100. Leaked a <think> block AND kept the leading "The" in the name ("The DeskPro X1 monitor stand"), so the extraction is slightly off.
Verbatim output (139 in / 92 out tokens, 165 ms, $0.000118)
<think>
We need to extract product details: name, price, in_stock. Name is "The DeskPro X1 monitor stand". Price is 49.99. in_stock: currently available to ship => true. Return JSON only, no markdown. Ensure keys exact. Provide number, boolean, string.
</think>
{"name":"The DeskPro X1 monitor stand","price":49.99,"in_stock":true}

Verdict

For structured data on a budget, GPT-5.4 Nano took the top accuracy score (100/100) in this run. If raw throughput matters most, GLM 4.7 (Cerebras) was fastest at 562.9 tokens/sec, and Amazon Nova Micro was the cheapest to run. Every model here costs under $3 per million output tokens, so the real differentiator is how cleanly each one follows instructions — expand the rows above to judge for yourself.

More cheap-model tests

Code Generation
Writing a Code Snippet
View results →
Copywriting
Writing a Short Paragraph
View results →

Test it with your own prompt

Run all these cheap models side by side on the task that actually matters to you.

Open the live playground →