How to Use Claude (Anthropic): Access & Setup Guide

There are three practical ways to use Claude, Anthropic's family of AI models: through the claude.ai chat interface, through the Anthropic API for building your own applications, or through developer tools like Claude Code for terminal-based coding work. Which one you need depends entirely on what you're trying to do — chat with an assistant, build a product feature, or automate a workflow.

This guide walks through each path, the setup steps involved, and where a service like SubToAPI fits if you already have Claude access and want to expose it as a proper API for your own apps or team.

Option 1: Chat with Claude directly

If you just want to ask questions, draft text, analyze documents, or get coding help interactively, go to claude.ai and sign up. There's a free tier with usage limits, and paid plans (Pro, Team) that raise those limits and add features like larger context windows and priority access to new models.

This is the right choice if:

• You're a single user doing ad hoc work
• You don't need to integrate Claude into another piece of software
• You're fine with a chat UI rather than programmatic access

It's the wrong choice if you need Claude's output inside your own app, CI pipeline, or backend service — for that you need the API.

Option 2: Use the Anthropic API to build something

If you're a developer building a product feature — a support bot, a document summarizer, a code review tool — you'll want to call Claude programmatically. This means:

1. Creating an account in the Anthropic Console
2. Generating an API key
3. Sending requests to the Messages API

A minimal request looks like this:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Explain what a race condition is."}
    ]
  }'

The API supports streaming responses, tool use (function calling), vision inputs, and system prompts. It's billed per token, separately from any consumer subscription you might already have — the Claude Pro plan and the API are different products with different billing.

This is the right choice if you're writing code that needs to talk to Claude directly and you're comfortable managing API keys, rate limits, and billing at the account level.

Option 3: Turn existing Claude access into a shared API

Here's a scenario that trips people up: you or your team already pay for Claude (Pro, Team, or Max), and you want to build internal tools, prototypes, or small products on top of that access — without setting up a separate Anthropic API account, negotiating billing, or handing out one shared API key that nobody can track usage for.

This is the gap SubToAPI fills. It turns your existing Claude access into a clean HTTPS API with:

• Application-specific keys (sub_live_...) instead of one shared secret
• Streaming responses and tool use, matching the shape of the standard Messages API
• Per-key usage metadata so you know what's consuming your quota
• Team seats so multiple developers can each get scoped access from one dashboard

Once you're signed up, a request looks nearly identical to calling Anthropic directly — you just point at a different base URL and use your SubToAPI key:

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Summarize this changelog in three bullets."}
    ]
  }'

Or in JavaScript:

const res = await fetch("https://api.subtoapi.app/v1/messages", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.SUBTOAPI_KEY}`,
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Draft a release note." }],
  }),
});
const data = await res.json();

This is the right choice if you already have Claude access and want to give multiple apps or teammates controlled, trackable API access without duplicating billing setups. Plans start at €9/month for solo use, with Team (€19/seat) and Scale (€49/seat) tiers for larger groups — see /pricing for details.

Choosing between the three

A quick way to decide:

• Just chatting or writing? Use claude.ai.
• Building a product from scratch, comfortable managing a new API account? Use the Anthropic API directly.
• Already have Claude access and want to build several small tools or share access across a team with usage visibility? Wrap it with something like SubToAPI.

None of these are mutually exclusive — many teams use claude.ai for daily work and an API layer for the products they ship.

Getting started quickly

If you're going the API route with SubToAPI, the setup is short:

1. Create an account at /signup (free trial included)
2. Generate an application key from the dashboard
3. Follow /docs/quickstart to send your first request
4. Check /docs/messages for the full request/response shape, or /docs/streaming and /docs/tools if you need streamed output or function calling

There's no separate contract or billing negotiation — it's a normal SaaS signup, and you can cancel or downgrade a plan at any time.

FAQ

Is the Claude subscription the same as the Claude API?

No. A Claude Pro/Team/Max subscription gives you access to the chat app with higher usage limits. The API is a separate, usage-billed product for developers building software that calls Claude programmatically. They use different accounts and different billing.

Do I need to be a developer to use Claude?

No — claude.ai requires no coding at all. You only need developer skills if you're calling the API directly or building an application on top of it, whether through Anthropic's own API or a layer like SubToAPI.

Can multiple people on my team share one Claude API setup safely?

Yes, but a single shared API key makes it hard to track who's using what. SubToAPI addresses this with per-application keys and team seats, so each person or app gets scoped access and visible usage instead of one undifferentiated key. See /pricing for team plan details.