How to Manage Your Anthropic Account and API Keys: A Practical Guide

Introduction

If you're building with Claude, your first stop after signing up is the Anthropic Console — the central hub for managing your account, API keys, billing, and team access. Whether you're a solo developer or part of a larger organization, understanding how to navigate the Console is essential for keeping your projects secure and your costs under control.

This guide covers everything you need to know about the Company section of the Anthropic Console: from creating your first API key to setting up usage alerts and managing team members.

Prerequisites

Before you begin, make sure you have:

• An Anthropic account (sign up is free)
• A verified email address
• A credit card (if you plan to use paid API tiers)

Step 1: Accessing the Company Dashboard

Once logged into the Anthropic Console, navigate to the Company section. This is typically found in the left sidebar or under your profile menu.

The Company dashboard gives you an overview of:

• Organization name and settings
• Billing summary (current month usage, credits remaining)
• Team members and their roles
• API keys associated with your account

Step 2: Creating and Managing API Keys

API keys are how your applications authenticate with the Claude API. Each key should be treated like a password — never share it publicly or commit it to version control.

Creating a New API Key

• In the Company dashboard, click API Keys.
• Click Create Key.
• Give your key a descriptive name (e.g., "Production App" or "Dev Testing").
• Optionally, set a usage limit for this key (see Step 3).
• Copy the key immediately — you won't be able to see it again.

Using the API Key in Code

Here's how to use your API key with the Python SDK:

import anthropic
client = anthropic.Anthropic(
    api_key="sk-ant-..."  # Replace with your actual key
)
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)
print(message.content)

For TypeScript/Node.js:

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic({
  apiKey: 'sk-ant-...', // Replace with your actual key
});
async function main() {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1000,
    messages: [{ role: 'user', content: 'Hello, Claude!' }],
  });
  console.log(message.content);
}
main();

Rotating and Revoking Keys

For security best practices:

• Rotate keys every 90 days or after a security incident.
• Revoke any key that is compromised or no longer needed.
• Use separate keys for development, staging, and production environments.

To revoke a key, simply click the trash icon next to it in the API Keys list.

Step 3: Setting Usage Limits and Budget Alerts

One of the most important features in the Company section is the ability to set usage limits and budget alerts. This prevents unexpected charges.

How to Set a Usage Limit

• Go to Billing > Usage Limits.
• Click Add Limit.
• Choose between:

- Hard limit: API calls will be rejected once the limit is reached. - Soft limit: You'll receive an email alert, but API calls continue.

• Set the dollar amount (e.g., $100 per month).
• Save.

Configuring Budget Alerts

You can also set up alerts at multiple thresholds:

• 50% of budget used
• 80% of budget used
• 100% of budget used

These alerts are sent to the email address associated with your account.

Step 4: Managing Team Members

If you're working with a team, you can invite members to your Anthropic organization. This is useful for:

• Sharing API keys without exposing them
• Delegating billing management
• Collaborating on prompt engineering

Inviting a Team Member

• Go to Company > Team.
• Click Invite Member.
• Enter their email address.
• Choose a role:

- Admin: Full access to billing, keys, and team management. - Developer: Can create and use API keys, but cannot manage billing or team. - Viewer: Read-only access to usage data.

• Send the invitation.

Best Practices for Teams

• Use Admin roles sparingly — only for trusted leads.
• Regularly audit team members and remove those who have left.
• Encourage developers to use personal API keys for local development.

Step 5: Monitoring Usage and Billing

The Billing tab provides a real-time view of your API usage:

• Current month usage: Total tokens consumed and cost.
• Daily breakdown: See spikes or patterns.
• Model-level costs: How much you're spending on Claude Haiku vs. Sonnet vs. Opus.

Exporting Usage Data

You can export your usage as a CSV file for internal reporting or reconciliation. Look for the Export button in the Billing section.

Common Pitfalls and Troubleshooting

"Invalid API Key" Error

If you see this error:

• Check that you copied the key correctly (keys start with sk-ant-).
• Ensure the key hasn't been revoked.
• Verify you're using the key in the correct environment (e.g., not using a dev key in production).

Unexpected Charges

If you're surprised by your bill:

• Check your Usage Limits — did you set a hard limit?
• Review the Daily Usage chart for unusual spikes.
• Look for runaway loops in your code (e.g., infinite retries).

Rate Limiting

Anthropic applies rate limits based on your plan. If you hit rate limits:

• Implement exponential backoff in your code.
• Consider upgrading your plan for higher throughput.
• Use batch processing for non-real-time workloads.

Security Best Practices

• Never hardcode API keys in your source code. Use environment variables or a secrets manager.
• Use separate keys for different environments.
• Rotate keys regularly — set a calendar reminder.
• Monitor usage daily to catch anomalies early.
• Limit access to the Console to only those who need it.

Example of using environment variables:

import os
import anthropic
client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

Conclusion

Managing your Anthropic company account doesn't have to be complicated. By understanding the Console's key features — API keys, usage limits, team management, and billing — you can build confidently with Claude while keeping costs predictable and your account secure.

Start by creating a dedicated API key for your project, set a soft budget alert, and invite a teammate to collaborate. These few steps will save you headaches down the road.

Key Takeaways

• API keys are sensitive credentials — treat them like passwords, rotate them regularly, and never commit them to code.
• Set usage limits and budget alerts to prevent unexpected charges and maintain cost control.
• Use team roles to delegate access appropriately — Admin for billing, Developer for API usage, Viewer for read-only monitoring.
• Monitor your billing dashboard daily to catch unusual usage patterns early.
• Always use environment variables for storing API keys in production code.