Claude API Make.com Integration Tutorial

Make.com (formerly Integromat) doesn't have a native Claude module, so connecting Claude to a Make scenario means using the HTTP module to call an API directly. This guide walks through two working setups: calling the Anthropic API directly from Make, and calling it through SubToAPI to simplify auth and get usage visibility across scenarios.

If you're searching for "claude api make.com integration tutorial," you're probably trying to add AI text generation, summarization, or classification into an automated workflow — a form submission that gets a drafted reply, a spreadsheet row that gets enriched, a support ticket that gets triaged. Both approaches below get you there; the difference is in how much setup and maintenance you want to deal with.

Why Make.com Doesn't Have a Native Claude Connector

Make maintains official app modules for popular services, but LLM providers change their APIs frequently and Make doesn't ship a first-party Claude module. That means every Claude-in-Make tutorial you'll find relies on the generic HTTP > Make a request module, configured by hand. It works fine, but it means:

• You manage authentication headers yourself
• You build the JSON body manually for every scenario
• Error handling (rate limits, timeouts) is on you
• There's no built-in dashboard to see what each scenario is spending

This is normal for HTTP-based integrations, but it's worth knowing upfront so you're not hunting for a module that doesn't exist.

Option 1: Direct Anthropic API Call in Make

1. Add an HTTP module to your scenario, action type "Make a request."
2. Set the URL to the Anthropic Messages endpoint.
3. Method: POST.
4. Headers:

• x-api-key: your Anthropic key
• anthropic-version: a valid API version string
• content-type: application/json

1. Body type: Raw, Content type: JSON.

Example body:

{
  "model": "claude-3-5-sonnet-latest",
  "max_tokens": 1024,
  "messages": [
    { "role": "user", "content": "{{1.text}}" }
  ]
}

Replace {{1.text}} with the mapped field from a previous module (form input, spreadsheet cell, incoming email body, etc.).

The output you get back in Make is a JSON object. You'll parse content[0].text in a subsequent module to use the generated text downstream — sending it in an email, writing it to a database, posting it to Slack.

This works, but every time you add a Claude call to a new scenario you're rebuilding the headers and body from scratch, and if Anthropic rotates versions or you want to track cost per scenario, there's no central place to do that.

Option 2: Calling Claude Through SubToAPI in Make

SubToAPI wraps Claude access behind a standard HTTPS API with its own application keys (sub_live_...), so your Make scenarios authenticate the same way regardless of how your underlying Claude access is set up. It's useful in Make specifically because:

• You reuse one SubToAPI key across every scenario, instead of juggling provider keys
• Usage and cost per key are visible in one dashboard — handy when you have five scenarios each calling Claude and want to know which one is expensive
• Team seats let colleagues build scenarios without sharing a single raw credential

Setup is the same HTTP module pattern, pointed at SubToAPI instead:

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

In Make:

1. HTTP module, URL: https://api.subtoapi.app/v1/messages
2. Headers: Authorization: Bearer YOUR_SUBTOAPI_KEY, content-type: application/json
3. Body: same JSON structure as above, with {{mapped fields}} from earlier modules
4. Parse mode: JSON — Make will auto-detect the response structure for use in later modules

See the quickstart for the full request/response reference and /docs/messages for all supported parameters. If your scenario needs the model to call external tools (look up a CRM record, check inventory) before finishing its answer, /docs/tools covers tool definitions you can embed in the same request body.

Handling Longer Responses with Streaming

Make scenarios typically wait for a full HTTP response before moving to the next module, so streaming isn't usually necessary inside Make itself — but if you're building a Claude integration elsewhere (a custom webhook receiver that Make then triggers) and want token-by-token output, see /docs/streaming for how SubToAPI handles server-sent events.

Common Scenario Patterns

Form submission → AI draft → Email: Webhook/Typeform module → HTTP (Claude) → Gmail/Outlook module, mapping the generated text into the email body.

Spreadsheet row → classification → Update row: Google Sheets watch rows → HTTP (Claude) with a classification prompt → Google Sheets update row, mapping Claude's output to a category column.

Support ticket → summary → Slack post: Helpdesk trigger → HTTP (Claude) summarize → Slack message module.

In each pattern, the HTTP module is identical in structure — only the prompt and the mapped input/output fields change.

Error Handling in Make

Add an error handler route on the HTTP module to catch non-200 responses (rate limits, malformed input, auth failures). A simple pattern: if status is not 200, route to a "Resume" or notification module instead of letting the scenario fail silently. This matters more in production scenarios that run on a schedule rather than on manual triggers, since nobody's watching in real time when they fire.

Getting Started

If you want authentication and usage tracking handled without wiring raw provider headers into every Make scenario, sign up for a free trial and grab a sub_live_ key. Pricing starts at Solo for €9/month for individual builders; Team (€19/seat) and Scale (€49/seat) plans add seats for teams building multiple automations — see /pricing for details.

Questions

Does Make.com have an official Claude app? No. Make doesn't ship a native Claude module, so integrations use the generic HTTP module pointed at either the Anthropic API or an API wrapper like SubToAPI.

Can I use variables from earlier Make modules in the Claude prompt? Yes. Map any field from a previous module directly into the JSON body of the HTTP request, inside the messages content string, using Make's standard mapping syntax.

Is streaming useful inside a Make scenario? Rarely — Make modules wait for the complete HTTP response by default, so a standard non-streaming request is simpler and sufficient for most automation use cases.