Claude 2 Chatbot Tutorial: Build One With Current Models

If you searched for a "Claude 2 chatbot tutorial," you're likely following an older guide or blog post that references Claude 2, the model Anthropic shipped in 2023. Claude 2 has since been retired from general availability and replaced by newer model families (Claude 3, 3.5, and beyond), so a tutorial built specifically around Claude 2's API calls will mostly still work — the request/response shape barely changed — but you should point your code at a current model name instead of claude-2.1 or claude-2.0.

This tutorial walks through building a working chatbot the same way a Claude 2 tutorial would have, but using the model identifiers and patterns that are actually supported today. By the end you'll have a script that sends messages, keeps conversation history, and streams responses back to a user.

What changed since Claude 2

Claude 2 introduced the basic shape still used today: a messages array with role and content, a system prompt field, and a max_tokens parameter. If you have old Claude 2 code, the fix is usually one line — swap the model string. Everything else (message roles, streaming events, error codes) is compatible or has a documented equivalent.

What's actually new since Claude 2:

• Vision input — you can send images alongside text.
• Tool use — the model can call functions you define and return structured output.
• Longer context windows — Claude 2 topped out around 100K tokens; current models go higher.
• Better instruction following, which matters a lot for chatbots that need to stay in character or follow strict formatting rules.

Step 1: Get API access

You need a way to call a Claude model over HTTPS. There are two common paths:

1. Direct API access through Anthropic, with your own API key and billing.
2. A pass-through service like SubToAPI, which turns an existing Claude subscription into an HTTPS API with its own sub_live_... keys, so you don't have to set up separate API billing to start building.

Either way, the code you write is nearly identical — you're sending JSON to a /v1/messages-style endpoint.

Step 2: Send your first message

Here's a minimal request using SubToAPI's endpoint, which mirrors the standard messages format used across the ecosystem:

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 500,
    "messages": [
      { "role": "user", "content": "Explain what a chatbot loop is in one paragraph." }
    ]
  }'

The response contains a content array with the model's reply, plus usage metadata (input/output token counts). If you're coming from a Claude 2 tutorial, this is the exact structure you'd have used — just with a current model name. See /docs/messages for the full request/response reference.

Step 3: Build the conversation loop

A chatbot isn't a single request — it's a loop that keeps history and sends the whole conversation back each time, since the API is stateless.

const messages = [];

async function sendMessage(userText) {
  messages.push({ role: "user", content: userText });

  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-3-5-sonnet-20241022",
      max_tokens: 800,
      system: "You are a concise, friendly support assistant.",
      messages,
    }),
  });

  const data = await res.json();
  const reply = data.content[0].text;
  messages.push({ role: "assistant", content: reply });
  return reply;
}

Every turn appends both the user message and the assistant's reply to the messages array, so the model always sees full context. This is the core loop behind every Claude-based chatbot, regardless of which model version you're using — it's exactly how it worked with Claude 2, and it's how it works now.

Step 4: Add streaming for a real chat feel

Waiting for a full response before showing anything makes a chatbot feel slow. Streaming sends tokens as they're generated:

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-3-5-sonnet-20241022",
    max_tokens: 800,
    stream: true,
    messages,
  }),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  process.stdout.write(decoder.decode(value));
}

Full event details, including how to parse the SSE chunks, are in /docs/streaming.

Step 5: Manage cost and context length

Long-running chatbots accumulate tokens fast. A few practical guardrails:

• Trim old history once the conversation exceeds a token budget — summarize earlier turns instead of sending everything verbatim.
• Set a hard max_tokens cap per response so a single reply can't blow your budget.
• Watch usage metadata returned with each response so you can log cost per conversation, not just per request.

If you're building this for a team rather than a solo project, a dashboard that tracks usage per API key across your team is worth having before you scale past a handful of users — this is one of the things SubToAPI's pricing plans (Solo, Team, Scale) are built around, alongside per-seat API keys so each teammate or environment can be tracked separately.

Step 6: Add tool use if your chatbot needs to take action

If your chatbot needs to look something up, call an internal API, or perform a calculation instead of just talking, tool use lets you define functions the model can invoke with structured arguments. That's covered in depth in /docs/tools, but the short version: you describe a tool's name, input schema, and purpose, and the model decides when to call it and with what parameters.

Getting started quickly

If you want to skip the setup and start testing requests immediately, the /docs/quickstart guide walks through generating a key and making your first call in a few minutes, and /signup starts a free trial with no separate API billing setup required.

FAQ

Is Claude 2 still available for chatbot projects? Claude 2 has been phased out of general availability in favor of newer Claude model families. Existing code built for Claude 2 usually only needs the model name updated — the request format is unchanged.

Do I need to rewrite my chatbot code to move off Claude 2? Rarely more than the model identifier. Roles, message structure, and system prompts work the same way, though you should test output quality since newer models follow instructions differently.

What's the fastest way to build a Claude chatbot without managing separate API billing? Using a pass-through service like SubToAPI lets you generate an API key from an existing Claude subscription and start making requests immediately — see /docs/quickstart for setup steps.