Your first API call, with a spending cap

Use it when you have used chat apps and now want to call a model from a script, without a surprise bill or a leaked key.

Not when a chat plan already does the job. A script is worth it for repeated or bulk work, such as classifying a few hundred items.

You need a vendor account with billing set up, a terminal, and Python 3 if you want the Python version. About 30 minutes. The order of the steps is our suggestion. The settings, field names and prices are from the vendors' docs, read on 2026-10-10.

Short answer

Make the cap before the key. Create a separate project, set a monthly limit on it that actually stops requests, then create a key that can only reach that project. The trap: on OpenAI a spend limit only sends alerts until you turn on Enforce a hard limit. On Anthropic you cannot set a limit on the Default Workspace, so make a new one.

Step 1. A separate project with a hard cap

On OpenAI you can also pick which models a project may use, under Limits > Model Usage. Allowing only the small model below is a second guard.

Step 2. A key that only reaches that project

Choose 30 days or less for a first key (our suggestion). Copy it straight into your password manager, as Privacy settings pass says. Never paste a key into a chat, an email, a notes file or a script. Each person should have their own key; OpenAI says sharing keys breaks its terms of use.

Step 3. Put the key in an environment variable

Both SDKs read the key from an environment variable, so it never appears in your code: ANTHROPIC_API_KEY for Anthropic and OPENAI_API_KEY for OpenAI. On macOS or Linux, this asks for the key without showing it and without saving it in your shell history (our suggestion):

read -rs ANTHROPIC_API_KEY && export ANTHROPIC_API_KEY
read -rs OPENAI_API_KEY && export OPENAI_API_KEY

Paste the key when the cursor waits, then press Enter. It lasts until you close the terminal. For anything that runs unattended, both vendors recommend a secrets manager instead.

Step 4. One call with curl

We use each vendor's small, cheap model: claude-haiku-5-5 and gpt-6-luna.

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -d '{"model": "claude-haiku-5-5", "max_tokens": 1000,
       "messages": [{"role": "user", "content": "<YOUR_PROMPT>"}]}'

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{"model": "gpt-6-luna", "max_output_tokens": 1000,
       "input": "<YOUR_PROMPT>"}'

Replace the following:

• <YOUR_PROMPT>: a short test, such as Name three uses of a paperclip. Nothing private: see What not to paste.

max_tokens and max_output_tokens cap the length of each reply, and so the cost of each call. The variable name in the command is expanded by your shell, so the key itself is never typed into the command.

Step 5. The same call in Python, with its cost

Install the SDK in a virtual environment: pip install anthropic or pip install openai. The prices below are per million tokens for these two models, for prompts up to 100,000 tokens on Haiku 5.5 and short context on luna.

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=1000,
    messages=[{"role": "user", "content": "<YOUR_PROMPT>"}],
)
for block in message.content:
    if block.type == "text":
        print(block.text)

u = message.usage
cost = (u.input_tokens * 0.10 + u.output_tokens * 0.50) / 1_000_000
print(u.input_tokens, "in,", u.output_tokens, "out, about $" + f"{cost:.7f}")

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-luna",
    max_output_tokens=1000,
    input="<YOUR_PROMPT>",
)
print(response.output_text)

u = response.usage
cost = (u.input_tokens * 0.10 + u.output_tokens * 0.50) / 1_000_000
print(u.input_tokens, "in,", u.output_tokens, "out, about $" + f"{cost:.7f}")

The curl and Python calls are our suggestion; we could not run them without an API key.

Reading the usage fields

Cost = input tokens × input price ÷ 1,000,000 + output tokens × output price ÷ 1,000,000. An example (illustrative): 15 input and 120 output tokens on either model cost 15 × $0.10 / 1M + 120 × $0.50 / 1M = $0.0000615. A thousand such calls cost about 6 cents.

Put in your own call to see how far a cap goes. It starts on the example above.

Cheaper later. If you can wait for results, batch pricing is half (the Batch column). Prompt caching pays only when many calls share a long, identical opening; a first test call is far below the minimum.

Gemini. Same pattern: a project cap at Spend > Monthly spend cap in AI Studio (labelled experimental), the key in GEMINI_API_KEY, and the paid tier for anything private, since Google says free-tier use may be used to improve its products.

If a key leaks

1. Disable or delete it now. Anthropic: Settings > API keys, where Disable can be undone and Delete cannot. OpenAI: rotate it on the API Keys page. Gemini: create a new key, deploy it, then disable the leaked one.
2. Replace it in your environment and any running job.
3. Check usage and billing for calls you did not make. OpenAI asks you to contact it through help.openai.com for anything further.

GitHub's secret scanning partner programme scans public repositories and alerts the provider, and Anthropic and OpenAI are both partners. Do not rely on it: a key can be used before anyone revokes it.

How to tell it worked

• The project or workspace shows a monthly limit, and on OpenAI Enforce a hard limit is on.
• The key's page shows it scoped to that project, with an expiry date.
• Searching your project folder for the first ten characters of the key, such as grep -r "<KEY_START>" ., finds nothing.
• Both calls printed a reply and two token counts, and your computed cost matches the usage page the next day.
• You know the error you will see at the cap: HTTP 400 on Anthropic, HTTP 429 project_spend_limit_exceeded on OpenAI.

Limits

Try this next

1. Run the same ten tasks through the small model and your usual one, and compare: Test any new model on your own tasks.
2. Set a calendar reminder for the day your key expires.

Sources

1. Anthropic. Rate limits and spend limits. Vendor documentation. Link
2. Anthropic. Workspaces. Vendor documentation. Link
3. Anthropic. Get an API key, and Authentication. Vendor documentation. Link · Link
4. Anthropic. Models overview, Pricing, Create a message, Prompt caching. Vendor documentation. Models · Pricing · API · Caching
5. OpenAI. Spend limits, and Production best practices. Vendor documentation. Link · Link
6. OpenAI. Managing projects, and Best practices for API key safety. Help centre. Link · Link
7. OpenAI. Quickstart, Models, Pricing, Reasoning, Prompt caching, Batch. Vendor documentation. Quickstart · Models · Pricing · Reasoning · Caching · Batch
8. Google. Gemini API billing, API keys and pricing. Vendor documentation. Billing · Keys · Pricing
9. GitHub. Secret scanning for partners, and supported patterns. Vendor documentation. Link · Link · 2021 changelog

Changes

1. v1.010 Oct 2026first version