GPT-6.1 Sol pricing and access: what I set up in 25 minutes

If you're planning to build on GPT-6.1 Sol, the questions that actually matter are pretty boring: what does one task cost me, and what needs to be switched on before the first paid call goes through? I went from a fresh platform account to a working request plus a cost-per-task number in about 25 minutes. Below is the path I took, including the three errors that ate most of that time.

Difficulty here is basic. You need a terminal, a payment method, and the patience to read a pricing page twice.

What has to be in place first

Before you touch billing, confirm the basics:

• OS: Windows 10/11, macOS 12+, or Ubuntu 20.04+ with a POSIX shell. On Windows, use Git Bash or WSL so curl and export behave the way the commands below assume.
• curl 7.68+ for raw HTTP, or Python 3.9+ with the openai SDK.
• A platform account whose role can open Billing. A plain ChatGPT login is not the same thing as platform billing access.
• A payment method attached in Billing. The announcement does not list which cards or which countries are accepted, so check the billing page itself before you plan anything.
• One API key created in the dashboard. It is shown once, at creation time.
• The current pricing table for Sol open in a second tab. The dollar amount per token lives there, not in the announcement.
• Roughly 200 MB of free disk for the SDK and its dependencies.

A quick sanity checklist before you continue:

• [ ] Billing page opens and shows a payment method
• [ ] API key is copied somewhere safe
• [ ] python --version prints 3.9+ or curl --version prints 7.68+
• [ ] Pricing table is visible, with input and output price per 1M tokens

For the SDK route, pip install openai followed by pip show openai should print Name: openai plus a version line. That confirms the package is importable by the same interpreter you will run the script with.

Step 1: pick the model line that matches your task

Two lines exist in this generation, and they are priced differently. Sol is the cheaper line aimed at routine work: summarization, text generation, rewriting. Luna is the more expensive line for long context and multi-step reasoning where many conditions have to hold at once. The announcement says Sol's prices were cut by 50% versus the previous GPT-6 line, and describes it as near-Astra intelligence at roughly one fifth of the price.

Model	Best for	Price signal
GPT-6.1 Sol	Routine work: email summarization, text generation	50% cut vs. the previous line; near-Astra intelligence at about one fifth of the price
GPT-6.1 Luna	Long context and multi-step reasoning with many simultaneous conditions	More expensive than Sol; expected to beat it on hard benchmarks

A concrete split: "summarize this 400-word email thread into three bullets" is a Sol task. "Read these five contracts, compare the termination clauses, and list contradictions" is a Luna task. If most of your traffic looks like the first one, the 50% cut applies to nearly everything you send.

Step 2: enable billing, create a key, make one small call

Attach a payment method in Billing, create the key, export it as an environment variable, and fire a single small request. Never paste the key into the script file itself — keeping it in the environment means you can revoke it without editing code.

The reason this matters: Sol is billed per token, and a call without a valid payment method fails with a quota error rather than an auth error. That distinction is genuinely confusing when you are debugging at 11pm.

export OPENAI_API_KEY="<your-api-key>"
export SOL_MODEL_ID="<sol-model-id-from-pricing-page>"

curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"$SOL_MODEL_ID"'",
    "messages": [{"role": "user", "content": "Rewrite in one sentence: The invoice is due on Friday."}],
    "max_tokens": 64
  }'

The response should end with a usage block along these lines:

"usage": {"prompt_tokens": 18, "completion_tokens": 21, "total_tokens": 39}

One detail worth flagging: the model ID string is not printed in the announcement posts. Copy it verbatim from the pricing or models page and park it in SOL_MODEL_ID, so you only ever change it in one place.

The same request in Python, which is easier to reuse for batch work:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

resp = client.chat.completions.create(
    model=os.environ["SOL_MODEL_ID"],
    messages=[{"role": "user", "content": "Rewrite in one sentence: The invoice is due on Friday."}],
    max_tokens=64,
)
print(resp.choices[0].message.content)
print(resp.usage)

With max_tokens: 64 you get a one-line rewrite back plus a usage object. If total_tokens is non-zero, billing is live and the model answered. That is the entire access check.

Step 3: verify access and compute your real cost per task

The 50% cut and the "one fifth of the price" comparison only become numbers you can plan with once they meet your own average prompt length. A short prompt and a long one can differ by an order of magnitude in cost.

Send a fixed test prompt 10 times, sum total_tokens, then apply the per-million rates from the pricing page:

cost_per_task = (prompt_tokens     / 1_000_000) * input_price_per_1M
              + (completion_tokens / 1_000_000) * output_price_per_1M

Say your fixed prompt averages 400 prompt tokens and 120 completion tokens, and the pricing page lists <input price per 1M> and <output price per 1M>. Then 1,000 calls per day cost 1000 * (0.0004 * input + 0.00012 * output). Fill both placeholders from the Sol pricing page — don't borrow rates from another model line.

After that, set a monthly spend limit in Billing and check the usage dashboard following your next call. The request count should increase by exactly the number of calls you made.

The three errors I ran into

401 invalid_api_key. The message reads Error code: 401 - {'error': {'message': 'Incorrect API key provided: sk-...', 'type': 'invalid_request_error', 'code': 'invalid_api_key'}}. Common causes: the key was revoked, copied with a trailing space, or the variable was exported in a different shell session than the one running the command. Create a fresh key, re-export it, and verify:

echo "key length: ${#OPENAI_API_KEY}"
curl https://api.openai.com/v1/models -H "Authorization: Bearer $OPENAI_API_KEY"

The second command must come back with a JSON list, not an error object.

429 insufficient_quota. A valid key still fails with You exceeded your current quota, please check your plan and billing details. That means no payment method attached, a declined card, or a spend limit already reached. The key itself is fine — this is a billing-state error. Fix it on the Billing page and re-run the Step 2 command; re-issuing the key will never help here.

404 model_not_found. The model 'gpt-6.1-sol' does not exist or you do not have access to it. The ID was typed from memory instead of copied, or your account does not have access to that line yet. List what your account can actually call and copy the exact string from there, for example with curl https://api.openai.com/v1/models -H "Authorization: Bearer $OPENAI_API_KEY".

This article was originally published on AI Release — https://ai-release.org. If you want more walkthroughs like this one, the channel is at https://t.me/ai_release1.

Takeaway

Cost planning happens after you measure, not before. Attach billing first, keep the model ID in an environment variable so a typo can't masquerade as an access problem, and always convert the announced discount into your own cost-per-task figure before you commit to a budget. And remember the split that caused me the most confusion: a quota error is a billing problem, a 401 is a key problem, and a 404 is almost always a copy-paste problem.