Claude API Integration with Make.com: Setup Guide

Connecting Claude to Make.com

If you want to trigger Claude from a Make.com scenario — summarizing form submissions, drafting email replies, classifying support tickets, or generating content on a schedule — you don't need a custom app. Make.com doesn't ship a dedicated Claude module, but its generic HTTP module handles the Anthropic Messages API (or any Claude-compatible HTTPS endpoint) without writing code.

This guide covers the actual integration: authenticating the request, structuring the JSON body, parsing Claude's response inside Make, and the gotchas that trip people up the first time (header casing, token limits, and streaming not being supported in a single HTTP action).

What you need before you start

• A Make.com account with access to the HTTP module (available on the free tier for basic calls, Apps module for more complex flows)
• An API key — either directly from Anthropic's console, or an application key from a service like SubToAPI if you're routing your existing Claude subscription through an HTTPS API
• A target scenario trigger: a webhook, a Google Sheets row, a form submission, a schedule, etc.

The integration pattern is identical regardless of where the key comes from, because both expose a standard REST endpoint that accepts JSON and returns JSON.

Step 1: Add an HTTP module to your scenario

In Make.com, search for HTTP > Make a request. This is the generic action that lets you call any API, including Claude's.

Configure it like this:

• URL: https://api.anthropic.com/v1/messages (or https://api.subtoapi.app/v1/messages if you're using SubToAPI)
• Method: POST
• Headers:
• Content-Type: application/json
• x-api-key: YOUR_API_KEY (Anthropic) or Authorization: Bearer YOUR_KEY (SubToAPI)
• anthropic-version: 2023-06-01 (required by Anthropic's native API)
• Body type: Raw / JSON

Step 2: Build the request body

This is where most scenarios break — Make's HTTP module expects valid JSON, and any upstream module data (like a webhook payload or Google Sheets cell) needs to be mapped into the body string carefully, with quotes escaped if you're not using Make's native JSON builder.

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

{{1.text}} refers to a field from a previous module — for example, the body of an incoming form submission or a cell value from a spreadsheet row. Make automatically escapes this if you use the module's mapping panel instead of typing raw text.

If you're testing with curl before wiring up the scenario, the equivalent call looks like:

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 ticket in two sentences."}]
  }'

Running the curl version first saves you debugging time inside Make's slower iteration loop.

Step 3: Parse the response

Claude's response comes back as JSON with the generated text nested inside a content array. In Make, after the HTTP module runs, add a JSON > Parse JSON module (or just reference the HTTP module's output directly — Make usually parses it automatically) and map:

{{2.data.content[].text}}

That gives you the generated text as a usable variable for the next step — writing to a sheet, posting to Slack, sending an email, or updating a CRM record.

Why authentication trips people up

Two issues account for most failed scenarios:

1. Wrong header name. Anthropic's native API uses x-api-key, not Authorization: Bearer. If you copy a header pattern from OpenAI documentation, the request will 401.
2. Missing anthropic-version header. Without it, Anthropic's API rejects the request even with a valid key.

If you're managing Claude access for a team and want to avoid distributing raw Anthropic keys (and the versioning/header quirks that come with them) across multiple Make scenarios, routing through SubToAPI simplifies this: you get a standard sub_live_... key, a single Authorization: Bearer header, and no version header requirement. It also gives you per-scenario usage visibility in one dashboard instead of digging through Anthropic's console. See the quickstart and Messages API reference for the exact request shape.

Example scenario: ticket triage automation

A common build:

1. Trigger: new row in Google Sheets (support ticket exported from a form)
2. HTTP module: send the ticket body to Claude with a prompt like "Classify this ticket as billing, technical, or general, and return one word."
3. Router: branch based on Claude's response
4. Action: assign the ticket to the right Slack channel or team member

This runs entirely inside Make with one HTTP call per ticket — no backend server required.

Handling longer outputs and tool use

The HTTP module in Make does a single request/response cycle, so streaming responses aren't usable inside a standard scenario — you'll get the full completion at once, which is fine for most automation use cases. If your workflow needs Claude to call external tools (looking up data, running calculations) before returning a final answer, you'll need to handle the tool-use loop manually across multiple HTTP modules and a router, since Make has no built-in agent loop. Check the tool use docs if you're structuring that kind of multi-step request.

Common pitfalls

• Forgetting max_tokens — the API rejects requests without it
• Sending unescaped quotes from upstream text fields, breaking the JSON body
• Hardcoding the model name in a way that breaks when you switch models later — use a Make variable instead
• Ignoring rate limits — high-volume scenarios (processing hundreds of rows) should add a delay module between iterations

Questions

Does Make.com have a native Claude app? Not a dedicated one as of now. The generic HTTP module covers all functionality — requests, headers, and JSON bodies — so you're not missing anything by using it instead of a dedicated connector.

Can I stream Claude responses inside a Make scenario? No. The HTTP module waits for the full response before continuing, which works fine for most automation tasks but rules out token-by-token streaming within Make itself.

Do I need an Anthropic account, or can I use a third-party key? Either works as long as the endpoint accepts standard Messages API requests. Services like SubToAPI issue application keys that work with the same JSON body structure, just with simpler authentication headers.