Claude Integrations: What's Available and How to Build Your Own

When people search for "Claude integrations," they're usually after one of two things: a list of tools that already connect to Claude (Slack, Chrome, Google Workspace, IDEs), or a way to plug Claude into their own product or internal workflow. Both are covered here, but the second one is where most of the real engineering work happens, so that's where this article spends most of its time.

The short version: Anthropic ships a growing set of first-party integrations (desktop apps, browser extensions, Claude Code, Claude in Slack), supports the Model Context Protocol (MCP) for connecting Claude to external tools and data sources, and offers a direct API for anyone building custom software. If you already pay for a Claude subscription and want to reuse that access as an API for your own app, that's a separate problem — one SubToAPI (https://subtoapi.app) is built specifically to solve.

The Official Claude Integrations

Anthropic maintains a handful of first-party integrations aimed at different user types:

• Claude apps (desktop/web/mobile) — the standard chat interface, with support for file uploads, projects, and custom instructions.
• Claude Code — a CLI-based coding agent that runs in your terminal, reads and edits files, runs commands, and can be scripted into CI pipelines.
• Browser extension — lets Claude read and act on the page you're viewing.
• Slack, Google Workspace connectors — pull context from docs, sheets, and calendars directly into a conversation.
• MCP (Model Context Protocol) — an open standard that lets Claude connect to external tools, databases, and services through a common interface, rather than one-off integrations per tool.

These cover the "use Claude as an assistant" use case well. They're not designed for the case where you want Claude embedded inside your own product, calling it programmatically, streaming responses to your users, or wiring it into a backend job queue. For that, you need API access.

Where the Anthropic API Fits

The direct Anthropic API is the standard way to build custom Claude integrations: you send a request with a model name, messages, and parameters, and get back a completion — optionally streamed, optionally using tool calls to let Claude invoke functions you define. This is the right layer for:

• Chat features embedded in your own SaaS product
• Backend automation (summarization, classification, extraction pipelines)
• Coding agents and internal dev tools
• Any workflow where you need structured, programmatic control over the model

The catch is billing and account structure. The Anthropic API is metered separately from a Claude Pro/Max subscription — different login, different billing, different rate-limit pool. If your team already has Claude subscription seats and you don't want to stand up a second billing relationship just to get API access, that's a real gap for a lot of teams, especially small ones that don't want two invoices and two dashboards for what feels like the same product.

Turning a Claude Subscription Into an API Integration

This is the specific problem SubToAPI addresses. It sits between your existing Claude access and your application, exposing a standard HTTPS API so you don't have to provision separate API billing to start building.

What you get:

• Application API keys (sub_live_...) scoped per app or per project
• Streaming responses for chat UIs and long-running generations
• Tool use so Claude can call functions you define, same as the native API pattern
• Usage metadata per key, useful for cost attribution across teams or products
• Team seats so multiple developers or products can share access under one dashboard

A basic request looks like this:

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

And in JavaScript, streaming a response into a UI:

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",
    max_tokens: 1024,
    stream: true,
    messages: [{ role: "user", content: "Draft a release note for v2.3.0" }],
  }),
});

const reader = res.body.getReader();
// read stream chunks and append to UI

For teams evaluating this route, the full request/response shape is documented at /docs/messages, streaming setup at /docs/streaming, and tool-calling patterns at /docs/tools. There's a free trial at /signup if you want to test against a real integration before committing, and plan details (Solo €9, Team €19/seat, Scale €49/seat) are at /pricing.

Choosing the Right Integration Path

A quick way to decide:

| Need | Best fit | |---|---| | Use Claude as a personal assistant across docs/Slack/browser | Native Anthropic apps + MCP | | Automate coding tasks in a terminal or CI | Claude Code | | Build a custom feature into your own product | Direct API or SubToAPI | | Reuse an existing subscription for API access without new billing | SubToAPI | | Connect Claude to internal tools/data with a standard protocol | MCP servers |

If you're integrating Claude into internal tooling that a small number of people use directly, native apps and MCP connectors are usually enough. Once you're building something that other users or systems call programmatically — a feature in your SaaS, a backend job, a bot — you're in API territory, and the decision becomes whether to set up separate API billing or route through an existing subscription via a service like SubToAPI.

Practical Tips for Building on Claude

• Start with the smallest model that meets quality bar. Test on a cheaper/faster model before defaulting to the largest one; it's often good enough and cuts latency and cost.
• Use streaming for anything user-facing. Non-streamed responses on longer generations feel broken to users waiting on a blank screen.
• Scope API keys per application, not per developer. Makes usage tracking and revocation far easier when something goes wrong.
• Log token usage per feature, not just per account. You'll want this data the first time someone asks "why did the bill jump."
• Treat tool definitions as part of your API contract. Changing a tool's parameters without versioning breaks any client relying on the old shape.

Getting started with any of this doesn't require picking a side permanently — you can start with SubToAPI's quickstart at /docs/quickstart, prototype a feature in an afternoon, and decide later whether to migrate to direct API billing as usage scales.

Questions

Do I need a separate Anthropic API account to build Claude integrations? Yes, by default — the Anthropic API is billed separately from a Claude subscription. Services like SubToAPI let you skip that step by exposing your existing subscription as an API.

What's the difference between MCP and API integrations? MCP is a protocol for connecting Claude to external tools and data sources inside a conversation (e.g., letting it query a database). A direct API integration is for embedding Claude's completions into your own software, independent of the Claude chat interface.

Can I stream Claude responses in a custom app? Yes — both the native Anthropic API and SubToAPI support streaming, which is the recommended approach for any chat-like or long-generation UI. See /docs/streaming for the setup.