Claude API Make.com Automation Tutorial

Connecting Claude to Make.com

Make.com doesn't ship a native Claude app in every account, so the practical way to call Claude from a scenario is Make's generic HTTP module, which lets you POST to any REST endpoint and parse the JSON response. This tutorial walks through building a working Claude automation in Make: setting up the HTTP request, handling authentication headers correctly, parsing the response, and wiring it into a real scenario (Google Sheets → Claude → Slack).

The two things that trip people up are the Anthropic authentication headers (x-api-key plus a separate anthropic-version header, instead of the more common single Authorization: Bearer pattern) and parsing the nested JSON response shape. We'll cover both, plus a simpler alternative if you want to skip the header juggling entirely.

What you need

• A Make.com account with at least one scenario slot
• An API key — either a raw Anthropic key or a sub_live_... key from SubToAPI
• A trigger app (Google Sheets, Airtable, webhook, Gmail — anything that starts a scenario)
• A destination app to send Claude's output (Slack, Notion, email, another sheet)

Option 1: Calling the Claude API directly with Make's HTTP module

Add an HTTP > Make a request module to your scenario and configure it like this:

URL: https://api.anthropic.com/v1/messages Method: POST Headers:

x-api-key: your-anthropic-key
anthropic-version: 2023-06-01
content-type: application/json

Body type: Raw, Content type JSON

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

{{1.text}} refers to a field coming from the previous module in your scenario — for example, a cell value from Google Sheets or an email body from Gmail.

Once the module runs successfully, Make will show the parsed output structure. Claude's response body looks like this:

{
  "id": "msg_01...",
  "content": [
    { "type": "text", "text": "Here is the summary..." }
  ],
  "usage": { "input_tokens": 120, "output_tokens": 48 }
}

To use the generated text in later modules, reference content[0].text — in Make's mapping panel this usually appears as Content[1]: Text after the module runs once and Make detects the structure.

Option 2: Using SubToAPI to simplify the setup

The two-header Anthropic auth scheme (x-api-key + anthropic-version) works fine, but it means every scenario, every teammate's key, and every header config has to be kept in sync manually. SubToAPI turns your existing Claude access into a standard HTTPS API with a single Authorization: Bearer sub_live_... header, so the HTTP module config is shorter and matches the auth pattern most other apps expect:

URL: https://api.subtoapi.app/v1/messages Headers:

Authorization: Bearer sub_live_your_key
content-type: application/json

Body:

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

This is useful if you're building Make scenarios across a team — you can issue a separate sub_live_... key per teammate or per automation from the dashboard, track usage per key, and revoke one without touching the others. See /docs/quickstart for the full request/response reference and /docs/messages for message formatting details.

Example scenario: auto-summarize form responses into Slack

A common use case is summarizing incoming text (support tickets, form submissions, long emails) and posting a digest to Slack. Here's the scenario structure:

1. Trigger: Google Forms / Typeform — new response
2. HTTP module: POST to Claude (either option above) with the form's long-text field as the prompt, asking Claude to summarize in 2–3 sentences and flag urgency
3. Text parser or JSON path: extract content[0].text from the response
4. Slack module: post the summary to a channel, using the extracted text

The prompt body for step 2 might look like:

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 300,
  "messages": [
    {
      "role": "user",
      "content": "Summarize this support request in 2 sentences and rate urgency as low/medium/high:\n\n{{1.message}}"
    }
  ]
}

Map the extracted summary into the Slack message module's text field, and the scenario runs end to end with no code.

Error handling and rate limits

Make will mark a module run as an error if the HTTP response isn't 2xx. For Claude calls, the most common non-2xx cases are:

• 401 — bad or missing auth header
• 429 — rate limited, add a small delay or a retry filter in Make
• 400 — malformed request body, usually a missing max_tokens or wrong model string

Add an error handler route in Make (right-click the HTTP module → Add error handler) so a failed Claude call doesn't break the whole scenario — route it to a fallback, like posting "summary unavailable" to Slack instead of silently stopping.

Streaming vs. non-streaming in Make

Make's HTTP module doesn't support reading Server-Sent Events, so streaming responses aren't useful here — always set "stream": false or omit the stream parameter entirely, and let Claude return the full response in one JSON payload. If you need streaming for a different part of your stack (a live chat UI, for example), that's a separate integration outside Make — see /docs/streaming for how streaming works when calling the API directly from your own app.

Managing keys across scenarios

If you're running more than one or two automations, avoid pasting the same API key into every HTTP module. Store it once as a Make connection or environment variable, and if you're on a team, issue separate keys per person or per scenario so you can see which automation is driving usage. Compare plans on /pricing if you need multiple seats for a team building several Make scenarios against the same underlying Claude access.

Questions

Does Make.com have a native Claude/Anthropic app? Coverage varies by account and region. The HTTP module approach shown here works regardless, since it just sends a standard REST request and doesn't depend on a pre-built connector being available.

Why use a Bearer token instead of Anthropic's x-api-key header? Both work. A single Authorization: Bearer header is just fewer fields to configure correctly in each Make module and matches the auth pattern most non-Anthropic apps in your stack already use.

Can I stream Claude's response into a Make scenario? No — Make's HTTP module reads a full response body, not a stream. Always disable streaming for Claude calls triggered from Make and let the full JSON come back in one response.