It is a secret credential that identifies and authorizes the software making a request.

API stands for application programming interface. It is a way for one program to ask another program to do something. When a developer wants an app, a website, or a script to use Claude, the program sends requests to the Claude API. Each request must prove that it is allowed to use the service, and the usual proof is an API key.

Anthropic’s documentation describes API keys as static secrets that you generate in the Claude Console and send with every request. Because the key is the proof, whoever holds it can use the service as you, and the usage is billed to your organization. This is why keys must be kept private.

Your Claude login and an API key are different things.

Many people first meet Claude through the chat apps, where you sign in with an account and type into a conversation. Developers who build their own products use a different route, the Claude API, which is managed through the Claude Console. The API uses keys, not your chat login. The two are set up separately, and they have separate billing. A paid chat subscription does not automatically give you API access, and usage through the API is generally billed through the Console. Anthropic has offered some plans with included API credits, but these details change, so check the current pricing and help pages.

flowchart LR
    P["A person"] --> A["Claude chat app
account login"]
    D["A developer's software"] --> K["API key
from the Claude Console"]
    A --> C["Claude"]
    K --> C
        

A leaked key can cost money, expose data, and be hard to trace.

Because a key acts as you, a leaked key lets a stranger run requests on your account. The first risk is cost: they can use Claude as much as the account allows, and you pay. The second risk is data: requests and responses that pass through your key may contain private information. The third risk is trust and reputation, since misuse of your key could be tied to your organization. Finally, finding out afterwards who used a leaked key and for what can take effort.

The process is quick, but each choice matters.

According to Anthropic’s documentation, you sign in to the Claude Console, open the API keys page under settings, and choose to create a key. You give the key a name, choose an expiration, and choose which account it is linked to. You can also choose a workspace to limit where the key works. After creating it, you copy the key and store it safely, because the full secret may not be shown to you again.

Different keys serve different purposes, and choosing the right one reduces risk.

Anthropic’s documentation describes personal keys, service account keys, and an older type called workspace keys. It also describes separate Admin API keys used for organization management. Personal and service account keys are generally preferred, because they stop working automatically when the linked account is removed from the organization, which prevents forgotten keys from lingering.

Keys should not live forever.

When you create a key, the documentation says you can choose an expiration, from short presets to a custom duration or no expiration, and that the choice is set at creation and cannot be changed afterwards. A shorter life limits the window in which a stolen key is useful. Keys without an expiration are meant for cases where you store them in a secrets manager and rotate them yourself.

Rotation means replacing an old key with a new one on a schedule, and then retiring the old one. A regular rotation habit means that even a key you never knew was exposed will eventually stop working. The usual approach is to create the new key, deploy it to the application, confirm everything works, and then delete the old key.

flowchart TD
    A["Create a new key"] --> B["Deploy it to the application"]
    B --> C["Confirm everything still works"]
    C --> D{"Working?"}
    D -- "Yes" --> E["Delete the old key"]
    D -- "No" --> F["Fix the deployment
and keep the old key until ready"]
    F --> B
        

A workspace is a boundary that limits what a key can reach.

Workspaces let an organization separate teams, projects, or environments, such as testing and production. Keys can be scoped to a workspace, so that a key created for a test project cannot be used for the production system. This is the digital version of giving different keys to different rooms, instead of one master key for the building.

Not everyone in an organization should be able to create keys.

Organizations assign roles that decide what each member can do. Anthropic’s documentation notes that if the create-key button is disabled, your role may not allow it, and you should ask an administrator. This is a feature, not an obstacle. Limiting who can create keys reduces the number of secrets floating around and makes it easier to know who is responsible for each one.

The safest place for a key is somewhere that is not in your code.

Anthropic’s documentation shows keys being provided to programs through an environment setting, and notes that its software development kits read a standard setting named for the Anthropic API key automatically. This keeps the key out of the program’s source code. For larger systems, a dedicated secrets manager, which is a protected vault with controlled access, is the better choice, since it also supports rotation and records who accessed a secret.

You rarely type the key into requests by hand.

Most developers use official software libraries from Anthropic. These libraries read the key from the environment and attach it to each request automatically, so the key never needs to be written into the program. If you make requests directly, the key is sent with each request in a header, as the documentation describes. If your key works across several workspaces, you also have to say which workspace a request is for.

The key point for beginners is that the key travels with every request, over a secure connection, from a place you control to Claude’s servers. That is why the code that uses the key should run in a place you control, such as a server, and not in a place that strangers can inspect.

Most leaks come from a small number of avoidable habits.

An AI assistant is a place where secrets get copied without anyone noticing.

When you ask an AI assistant to help debug your code, it is easy to paste in a whole file, including a key that is written in it. This puts the secret into a conversation history, and possibly into logs, shared chats, or exported documents. Even with good privacy practices, a secret should not be in a place that does not need to hold it. This applies to Claude and to any other AI tool.

The safer habit is to replace the real key with an obvious placeholder before sharing code, and to keep the real key in your environment. If you realize you have pasted a real key into a chat, treat it as exposed: replace it and delete the old one. Also check that files you upload do not contain keys hidden in settings or configuration.

Early warning turns a disaster into a small problem.

Usage through the API is billed by how much you use, so unexpected activity shows up as unexpected cost. Make a habit of looking at usage in the Console, and set up any limits and alerts that the Console offers for your organization and workspaces. Look for sudden spikes, activity at odd hours, and usage from keys you do not recognize. Naming keys clearly helps you spot which one is behaving strangely.

Speed matters more than perfection when a secret is exposed.

If you think a key has been exposed, do not wait to confirm. Guidance in public security resources, and Anthropic’s own approach as described in third-party summaries, is to revoke the key right away, create a replacement, and store the new one safely. Anthropic is reported to take part in a secret scanning partnership with a major code hosting platform, which can deactivate keys found in public repositories, but that is a safety net and not a plan. Keys exposed anywhere else need your action.

For larger systems, there are safer patterns than a key that lives for months.

Anthropic’s authentication documentation describes more than one way to authenticate. Alongside API keys, it describes workload identity federation, where software proves its identity through a trusted platform and receives short-lived credentials instead of a long-lived key. Credentials that expire in minutes or hours leave an attacker very little time. The documentation suggests API keys as the quick way to start, and the other methods as options for more advanced setups.

A team needs a few simple rules that everyone follows.

Familiar situations show how the rules apply.

Keys are simple and flexible, with responsibilities attached.

These habits cause most key leaks.

Follow these steps every time you use a key.

A few popular beliefs about keys are only partly true.

Quick answers to the questions beginners ask most.

It is a secret credential created in the Claude Console that lets your software make requests to the Claude API. Whoever holds it can use the API as your account.

In the Claude Console, on the API keys page in settings. It is separate from the chat apps. Follow the current instructions in Anthropic’s documentation.

No. Your login is for the chat apps, and an API key is for software that calls the API. They are managed and billed separately.

A personal key for your own development and a service account key for shared systems are generally preferred, since they stop working when the linked account is removed.

In an environment setting or, better, a secrets manager. Never in source files that are shared, uploaded, or committed.

No. Anything delivered to a user’s device can be inspected. Keep the key on a server and have your app talk to that server.

No. Replace it with a placeholder first. If you pasted a real one, rotate it right away.

Revoke it immediately in the Console, create a replacement, remove the leaked copy from where it appeared, deploy the new key, and review usage for the exposure window.

On a regular schedule that fits your risk, and immediately after any suspected exposure. Choosing an expiration at creation also helps.

Your role may not allow it. Ask an organization administrator to change your role or to create a service account key for your work.

In Anthropic’s official documentation for the Claude Console and the API, since steps, roles, and options can change.

An API key is the secret that lets your software use Claude, and it works like a credit card number: whoever holds it can spend as you. Keys are created in the Claude Console, separate from your chat login and usually billed separately. Choose the right type, give each key a clear purpose, scope it to a workspace, and set an expiration. Store it outside your code in an environment setting or a secrets manager, run the code that uses it on a server you control, and keep it out of public repositories, front-end code, chats, and screenshots. Watch usage, rotate on a schedule, and if a key ever leaks, revoke it at once and replace it. For larger systems, consider shorter-lived credentials, and always check Anthropic’s current documentation.