This post contains affiliate links; we may earn a commission at no extra cost to you.
If you’re building an MVP and want Claude doing the thinking inside a Make.com (formerly Integromat) scenario — summarizing support tickets, drafting replies, classifying inbound leads — you have two real options: Make’s native Anthropic Claude app, or a raw HTTP module hitting the Anthropic API directly. This walkthrough covers both, what each actually costs, and which one you should build on.
Option 1: Make’s native Anthropic Claude app
Make maintains a dedicated Anthropic Claude app (search "Anthropic Claude" in the module picker) with a handful of modules:
- Create a Prompt — send a text prompt, get Claude’s response back as a scenario variable. This is the one most builders reach for first.
- Ask Claude Vision — send an image (from a URL, uploaded file, or a prior module’s output) plus a text prompt; useful for OCR-style tasks like pulling line items off a receipt photo.
- Make an API Call — a generic authenticated-request module scoped to your connected Anthropic account, for endpoints the pre-built modules don’t cover yet.
- File and skill management modules for anyone using Claude’s Files/Skills features inside a scenario.
Setup: connect your Anthropic account by pasting an API key (from console.anthropic.com) into Make’s connection dialog once — every module in the scenario then reuses that connection. Drop a "Create a Prompt" module after your trigger (e.g., a new row in Google Sheets, a new email in Gmail), map the incoming text into the prompt field, pick a model, and map Claude’s output into your next step (a Slack message, a CRM field update, whatever).
The catch: as of this writing the native app doesn’t expose every parameter the raw API does — things like prompt caching controls or fine-grained stop sequences aren’t always surfaced in the module UI, and new model IDs can lag behind a few days after Anthropic ships them. For a straightforward "send text, get text back" flow, none of that matters. For anything more advanced, you’ll want Option 2.
Option 2: Raw HTTP module
Make’s built-in HTTP > Make a request module can call the Anthropic API directly, with full control over every parameter:
- URL:
https://api.anthropic.com/v1/messages - Method: POST
- Headers:
x-api-key: <your key>,anthropic-version: 2023-06-01,content-type: application/json - Body (raw JSON):
{"model": "claude-sonnet-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "<mapped text from prior module>"}]}
Parse the response with Make’s built-in JSON-parsing (either the HTTP module’s own "Parse response" toggle, or a follow-up "JSON > Parse JSON" module) to pull content[0].text into a variable you can use downstream.
This route gets you every model Anthropic offers the day it ships, full access to system prompts, prompt caching (cache_control blocks — genuinely worth using if you’re re-sending the same long context on every run), and the Batch API for non-time-sensitive jobs. The tradeoff is you’re maintaining the request shape yourself — if Anthropic changes a required field, your scenario breaks until you fix it, where the native app’s maintainers absorb that for you.
Anthropic vs Make module: quick comparison
| Native Claude app | Raw HTTP module | |
|---|---|---|
| Setup time | ~5 min (paste API key, pick a module) | ~15-20 min (build the request + parse the response) |
| Model access | Whatever’s in the module dropdown | Every model, same day Anthropic ships it |
| Prompt caching / advanced params | Limited/no UI exposure | Full control |
| Maintenance if Anthropic changes the API | Make’s team handles it | You handle it |
| Best for | MVP, non-technical builder, simple prompt-in/text-out | Cost-sensitive, high-volume, or advanced-feature scenarios |
What it actually costs
Two separate meters run here, and founders new to this stack often only budget for one.
Make’s own plan. Make’s 2026 pricing: Free (1,000 ops/month), Core (around $9/month billed annually, 10,000 ops/month), Pro (around $16-21/month, also 10,000 ops/month with add-on room), Teams (around $29/month, adds multi-user collaboration), and custom Enterprise. Every module execution — including your Claude call and the JSON parse step — burns one operation, so a scenario with a trigger + Claude call + Slack post is roughly 3 ops per run. At moderate volume (a few hundred runs a month) Core covers it comfortably.
The Anthropic API bill, separately. As of mid-2026, Claude Haiku 4.5 runs around $1/$5 per million input/output tokens, Sonnet 5 is around $3/$15 (with a discounted intro rate through August 31, 2026), and Opus 4.8 is around $5/$25. A typical "summarize this support ticket" call — a few hundred tokens in, a couple hundred out — costs a fraction of a cent on Haiku, and still well under a cent on Sonnet. The bill adds up at volume, not per-call; if you’re processing thousands of items a day, model choice matters more than it will feel like it does during testing. Prompt caching (available only via the raw HTTP route) cuts repeated-context input costs up to 90%, which is real money if every call resends the same long system prompt.
Which one should you actually build on?
For a first MVP, start with the native app — you’ll have a working automation in under 10 minutes and can validate the idea before optimizing anything. Switch to the raw HTTP module once you hit one of these triggers: you need a model or feature the module hasn’t added yet, your per-run cost is high enough that prompt caching would meaningfully help, or you’re running high enough volume that Make’s per-operation cost (not just the AI cost) starts mattering.
Our top pick: Make
FAQ
Do I need a separate Anthropic account, or does Make provide API access?
You need your own Anthropic account and API key from console.anthropic.com — Make doesn’t include Anthropic usage in its own subscription, they’re billed completely separately.
Can I use Claude’s prompt caching inside Make’s native app?
Not reliably as of this writing — cache control isn’t exposed in the module’s field list. If caching matters for your cost, use the raw HTTP module and add the cache_control block to your JSON body yourself.
Will my scenario break if Anthropic releases a new Claude model?
With the native app, you’ll wait for Make to add the new model ID to the dropdown (usually within a few days to a couple weeks). With the raw HTTP module, you can start using a new model the same day by just changing the model string in your JSON body.
Is the HTTP module harder to maintain long-term?
A bit — you own the request/response shape, so an Anthropic API change (rare, but it happens) means editing your JSON body rather than waiting on Make’s team. For most builders past the MVP stage, that tradeoff is worth it for the flexibility.
Pricing figures (Make plans, Anthropic per-token rates) reflect publicly listed rates as of mid-2026 — both vendors adjust pricing periodically, so confirm current numbers on make.com/pricing and anthropic.com/pricing before budgeting a production workflow.
