GPT-6.1 Terra: OpenAI’s $1 Model That Does Your Computer Chores — Invoices, Forms, Drawings — at Half Sol’s Price

Lena runs a six-person bookkeeping service. Every month her team retypes roughly 1,000 supplier invoices into accounting software by hand — the most boring hours on payroll. On October 26, 2026, OpenAI shipped the tool that eats exactly that kind of work: GPT-6.1 Terra, a model that can look at a screen, read an invoice, click through the right fields, and type the numbers in. The API price is $1 per million input tokens and $5 per million output tokens — half of GPT-6.1 Sol’s rates. Run the example math: 1,000 invoices at roughly 2,000 input tokens and 500 output tokens each costs about $4.50 on Terra, $9 on Sol, and $45 on flagship Astra. (Those token counts are an illustrative example, not a vendor quote — your invoices will vary.) This article shows what Terra is, where you can actually use it today, and how to turn it into a paid service this week.

What GPT-6.1 Terra is, in one paragraph

Think of Terra as a new hire who can both see and do. Most chatbots only answer in words. Terra can also read what’s on a screen — a scanned invoice, a technical drawing, a form — and then operate the computer the way a person would: click, type, move between apps. OpenAI calls this combination “visual reasoning plus precise computer use,” in plainer words: it understands pictures and documents, then takes action on them. It is the successor to GPT-5.6 Terra and sits in the middle of OpenAI’s lineup: cheaper than Sol and Astra, stronger than the cheaper Luna. A “token,” by the way, is just the unit OpenAI bills by — roughly three-quarters of an English word — so “per million tokens” is simply the price of feeding and receiving a large amount of text and images.

Where you can use it today — and where you can’t

• In ChatGPT: Terra is rolling out (being switched on gradually, account by account) in ChatGPT Work and Codex — the workspace and coding versions of ChatGPT — for Plus, Pro, Business, Enterprise, and Edu plans. It is not in regular Chat, and Free and Go plans are not listed. Rollout varies by account, region, and workspace settings, so if you don’t see it yet, it may simply not have reached you.
• As a developer: through the OpenAI API (the behind-the-scenes connection developers use to plug the model into their own software) as gpt-6.1-terra. Note the billing split that trips people up: a ChatGPT subscription does not include API usage. API calls are billed separately, per token.
• What it handles: text and image input, text output. It does not do audio or video, and fine-tuning (retraining it on your own data) is not supported.

The price card — verified 2026-10-27

Prices below are from OpenAI’s official API pricing page and the official announcement, checked the day this article was written.

Per 1M tokens (short context)	GPT-6.1 Terra	GPT-6.1 Sol	GPT-6 Astra
Input	$1	$2	$10
Cached input	$0.05	$0.10	$1
Output	$5	$10	$50

The worked example, line by line (1,000 invoices, illustrative token counts):

• Terra: 2,000,000 input × $1/1M = $2.00; 500,000 output × $5/1M = $2.50; total = $4.50
• Sol: 2,000,000 × $2/1M = $4.00; 500,000 × $10/1M = $5.00; total = $9.00
• Astra: 2,000,000 × $10/1M = $20.00; 500,000 × $50/1M = $25.00; total = $45.00

Two footnotes that protect you from a nasty surprise. Long-context requests — anything past roughly 272,000 input tokens in one request — bill at a higher tier: $2 input / $7.50 output per million on Terra. And cache writes (the first time a repeated prompt is stored for reuse) cost $1.25 per million, separate from the $0.05 cache-read rate. For the invoice job above, none of that matters: each invoice is a small, separate request.

What this means for you: if your work is high-volume and repetitive — invoices, forms, listings, quotes — Terra’s price turns a job that used to need human hours into a job that costs cents per document. That is the whole business case in one sentence.

Hands-on tutorial: your first Terra run in 10 minutes

No code needed for this path. You need a paid ChatGPT plan (Plus or above) with the Work rollout, or an OpenAI API key for the developer path at the end.

1. Open ChatGPT Work. Go to chatgpt.com and sign in. Switch to the Work workspace (not regular Chat). If you only see regular Chat, your account hasn’t received the Work rollout yet — check again in a few days.
2. Pick the model. Open the model picker at the top of the screen and select GPT-6.1 Terra. If it’s missing, your plan, region, or workspace hasn’t been switched on yet.
3. Give it a real invoice. Upload a photo or PDF of one supplier invoice — a real one you already processed, so you can check the result. Type this prompt (copy it as-is, then swap in your own details):

   Read this invoice and enter it into a table with these columns: vendor, invoice date, invoice number, line items with amounts, tax, total. Then tell me which accounting category each line belongs to, and flag anything that looks wrong — a total that doesn’t add up, a duplicate invoice number, a date in the future.

4. Check its work. Compare every number against the invoice. What you should see: a clean table plus one or two flags (or an explicit “nothing looks wrong”). For example, for an invoice like the ACME one below, the output table might read: vendor ACME SUPPLY, date Oct 12, 2026, invoice INV-8841, total $1,240.00, category “office supplies,” flag “totals match.” If a number is off, reply: “Line 3 doesn’t match — re-read the amount column and correct it.” That correction loop is the skill; the first pass is rarely the final pass.
5. Turn it into a repeatable job. Once one invoice works, paste five more in the same chat and ask for one combined table. Then ask: “Save this as my standard invoice format and use it every time.” You now have a template, not a one-off trick.
6. Scale it. If you process invoices weekly, repeat this with the whole batch and export the table (copy it into a spreadsheet). Time the run: if 50 invoices took you 10 minutes of checking instead of 3 hours of typing, you have your before-and-after number for selling this service.

Developer path (optional, 10 minutes): if you have an OpenAI API key, you can call the model directly. In a terminal, with your key saved as $OPENAI_API_KEY, this request returns a one-line invoice summary — replace the sample text with your own:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-terra",
    "input": "Extract vendor, date, invoice number, and total from this invoice text: ACME SUPPLY, Oct 12 2026, INV-8841, Total $1,240.00. Return a JSON object."
  }'

What you should get back: a JSON object (a structured format computers can read directly) like {"vendor": "ACME SUPPLY", "date": "2026-10-12", "invoice_number": "INV-8841", "total": 1240.00}. That machine-readable output is what lets you pipe results straight into accounting software instead of retyping them.

The money play: sell “invoice autopilot” to small businesses

The customer: bookkeepers, accountants, and small businesses (restaurants, clinics, contractors, e-commerce sellers) that receive 200–2,000 supplier invoices a month and still type them in by hand.

What you sell: a done-for-you invoice pipeline — they forward invoices to an email address or shared folder, you return a checked spreadsheet (or direct accounting-software import) within 24 hours. Terra does the reading and typing; you do the checking and the client relationship.

What you charge: $299/month for up to 500 invoices, $499/month up to 2,000 — or $2 per invoice for one-off clients. Your token cost at the example rates is under $5 per 1,000 invoices, so the margin is in your checking time and reliability, not in API spend. Start with one client at $299 and a written promise: “every number double-checked against the original, or the month is free.”

7-day validation plan:

1. Days 1–2: list 20 local businesses that complain about paperwork (bookkeepers first — they already believe the pain). Message 10 of them: “I turn a stack of supplier invoices into a checked spreadsheet in 24 hours. First 20 invoices free — if a number is wrong, you pay nothing.”
2. Days 3–4: run the free pilots with Terra using the tutorial above. Keep a simple log: invoices in, errors caught, minutes spent checking.
3. Day 5: send each pilot client their spreadsheet plus one line: “You just saved ~X hours of typing.” Ask for the $299/month subscription, starting with the next batch.
4. Days 6–7: one paying client = validated. Two = raise the price for the next one. Zero = ask what stopped them (usually trust, not price) and offer a one-week paid trial at $99.

OpenAI’s claims, decoded (vendor claims, not independently verified)

OpenAI’s own announcement says Terra is a “significant step up” from GPT-5.6 Terra. Here’s what the company itself reports — treat all of it as vendor claims, not independently verified:

• Agents’ Last Exam (professional computer tasks, e.g. turning an architectural drawing into a 3D model): at medium reasoning effort (how hard the model is set to think), Terra scores 15 points higher than GPT-5.6 Terra at about one-third the cost, and performs on par with Astra at one-tenth Astra’s price per token.
• Speed: over 3× faster than both GPT-6 Astra and GPT-6.1 Sol, per OpenAI.
• Factual errors: on OpenAI’s internal error-inducing prompts, the error rate at low effort fell from 53.6% (GPT-5.6 Terra) to 16.7%; at maximum effort it fell to 4.3%, nearly matching Astra and Sol.
• Coding (Terminal-Bench 4.0): 50.3% of tasks solved at maximum effort, more than double GPT-5.6 Terra’s 21.5%.
• Visual reasoning (MMMU-Pro, OSWorld 2.1): beats GPT-5.6 Terra at every reasoning setting and nearly matches Astra and Sol at much lower cost.

The honest caveats, including OpenAI’s own: for the most complex coding tasks, OpenAI itself says Sol and Astra remain the better choice. Terra is the bulk-workhorse pick, not the frontier pick. And per-token price is not per-task cost — a model that takes more steps can erase a price advantage, so measure cost per finished invoice, not cost per token, before you promise clients a price.

Pitfalls and limits

• You may not see it yet. The rollout depends on plan, region, workspace settings, and timing. “Not in my model picker” is a rollout fact, not a bug — recheck, and don’t pay anyone who promises to “unlock” it for you.
• Regular Chat doesn’t have it. If you open normal ChatGPT and can’t find Terra, that’s expected — it’s a Work and Codex model.
• Subscription ≠ API. Your Plus subscription does not pay for API calls. Budget them separately.
• Long documents reprice. Requests past ~272K input tokens jump to the $2/$7.50 tier. Invoices are small; a 500-page contract dump is not — split big jobs into per-document requests.
• It reads images, not audio or video. Don’t pitch a client on transcribing calls or editing video with Terra — the announcement’s “editing videos” example is about computer-use workflows around video files, not generating video.
• Check every number. Terra’s error rate improved, it did not reach zero. The service you sell is the checking, not the raw output.

FAQ

What is GPT-6.1 Terra? OpenAI’s mid-priced model for everyday computer work, launched October 26, 2026. It reads screens and documents (invoices, forms, drawings) and operates software the way a person would — clicking, typing, filling fields — at $1/$5 per million input/output tokens via the API.

How much does GPT-6.1 Terra cost? $1 per million input tokens, $0.05 per million cached input tokens, $5 per million output tokens — confirmed on OpenAI’s official pricing page on 2026-10-27. That is half of GPT-6.1 Sol ($2/$10) and one-tenth of flagship Astra ($10/$50) on input/output rates.

Can I use it in normal ChatGPT? No — at launch it’s in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu plans, not regular Chat, and not on Free or Go plans. Availability varies by account during the rollout.

Do I need to know how to code? No for the ChatGPT Work path — uploading an invoice and writing a prompt is enough. The API path needs a developer (or a freelancer for a day) to wire it into accounting software, which is exactly the service in the money play above.

When should I pick Sol or Astra over Terra? The hardest coding and research tasks — OpenAI itself says Sol and Astra stay better there. Terra wins on high-volume, well-scoped computer chores where price per finished task is what matters.

Is it really half the price of Sol? On standard API rates, yes: $1 vs $2 input, $5 vs $10 output, $0.05 vs $0.10 cached. But your real bill depends on how many tokens your job uses — long requests over ~272K input tokens bill at Terra’s higher $2/$7.50 tier, so keep jobs per-document.

References

• OpenAI — Introducing GPT-6.1 Terra (official announcement): https://openai.com/index/introducing-gpt-6-1-terra/
• OpenAI — API pricing (official pricing docs): https://developers.openai.com/api/docs/pricing
• Related on this site: GPT-6.1 Sol: OpenAI’s $4 Model vs the $20 Flagship — the bigger sibling Terra undercuts by half, and the pick-when guide for the hardest jobs.