Claude Projects cannot be called programmatically inside Make.com, n8n, or other automation tools — Anthropic has not exposed Projects as an API endpoint. You can replicate everything a Project provides (persistent instructions, document context, conversation memory) by injecting a stored system prompt, fetching relevant documents at runtime, and managing conversation history in external storage on every Anthropic Messages API call.
system parameter for instructions, the messages array for document context, and external storage for memory.Claude Projects, available inside Claude.ai, bundle three things into a single UI experience: a persistent system prompt applied to every conversation in the project, shared knowledge files you upload once and reference across sessions, and conversation scoping that keeps project chats separate from your general Claude history. [1] That's the full feature set — there is no additional model capability underneath.
Automation platforms like Make.com have no native "Call Project" module because Anthropic has not exposed Projects as a discrete API endpoint. The feature was designed as a user-experience wrapper for the Claude.ai interface, not as a programmable resource. This question came up in the r/ClaudeAI community, and the confusion is understandable — Projects feel like a persistent AI configuration, so it's natural to want to reference them in code.
The mental model shift that unlocks everything: instead of thinking "I need to call a Project," think "I need to recreate what a Project provides on every API call." The Claude Messages API lets you do exactly this across any HTTP-capable automation tool. [2]
In the Claude.ai UI, you give a Project a set of instructions. In API calls you send those same instructions as the system parameter in your request body. A Make.com HTTP module calling the Anthropic API uses this structure:
{
"model": "claude-opus-4-5",
"max_tokens": 1024,
"system": "You are a Google Ads specialist. Analyze campaign performance and suggest budget adjustments. Output recommendations as structured JSON. Never recommend increasing spend on campaigns with ROAS below 2.0.",
"messages": [
{
"role": "user",
"content": "{{Campaign performance data from previous step}}"
}
]
}
Store this system prompt in a Make.com Data Store record, a Google Sheet cell, or a Notion property — not hardcoded in the HTTP module body. Retrieve it dynamically on each run and map it into the system field.
Projects let you upload files that Claude references across conversations. In the API, you pass that same content inside the messages array — either as text in the user turn or using Claude's document support for PDFs and other file types. [2]
A practical approach for most marketing automation workflows:
Projects in the Claude UI retain a thread of conversation history scoped to that project. The API is stateless — it remembers nothing between calls unless you supply previous messages explicitly. [3] For automation workflows, this is an advantage once you architect it correctly.
| Storage option | Best for | Complexity | Approximate cost |
|---|---|---|---|
| Make.com Data Stores | Simple key-value memory, short threads | Low | Included in Make plan |
| Google Sheets | Logging outputs, human-reviewable history | Low | Free |
| Airtable / Notion DB | Structured memory with filtering & retrieval | Medium | ~$10–$20/mo |
| Supabase / PostgreSQL | Production agents, multi-user, vector search | High | Free tier → scales |
| Pinecone / Weaviate | Large document libraries, RAG | High | $70+/mo at scale |
In production I cap conversation threads at 15–20 turns before summarizing and starting a compressed context. Beyond that, you're paying for tokens with diminishing returns on output quality — and older messages carry less influence on Claude's response regardless of context window size.
---Make.com's generic HTTP module handles Anthropic API calls cleanly even without a native Claude connector.
https://api.anthropic.com/v1/messagesx-api-key: your Anthropic API key (stored in Make.com secrets, never in the module body)anthropic-version: 2023-06-01content-type: application/jsonmodel, max_tokens, system, and messagesTo replicate a "Project," add a Data Store lookup module before the HTTP call that retrieves your stored system prompt and any relevant document snippets, then map those values into the HTTP body using Make.com's variable syntax.
If your workflow requires back-and-forth with Claude rather than single-shot calls, follow this pattern — similar to what multi-step Claude workflows look like in practice:
messages parameter in your API call.Projects and the API serve different trigger patterns — the right choice depends on how a task is initiated, not which tool is "better."
| Scenario | Claude Projects UI | API in automation |
|---|---|---|
| One person, ad-hoc research | ✅ Ideal | ❌ Overkill |
| Team sharing prompts & context | ✅ Good for collaboration | ⚠️ Requires shared storage setup |
| Triggered automations (cron, webhook) | ❌ Not possible | ✅ Native use case |
| Processing bulk data (100+ records) | ❌ Manual, slow | ✅ Loop at scale |
| Integrating Claude output into other tools | ❌ Copy-paste only | ✅ Direct data passing |
| Non-technical users running tasks | ✅ UI is accessible | ⚠️ Needs a front-end wrapper |
These examples use the Project-replication pattern above and represent the kinds of workflows I build on top of Claude for advertising and marketing teams. You can see a fully built version of this approach in Buddy, the AI Google Ads agent.
A scheduled Make.com scenario runs every morning. It pulls the previous day's campaign data from the Google Ads API [4], injects a system prompt stored in a Data Store (the same instructions I'd put in a Claude Project), and asks Claude to flag any campaigns with ROAS below 1.5x or CPA above target thresholds. Claude's analysis posts to a Slack channel automatically — no one needs to open a dashboard.
When a new product is added to a Shopify store, a webhook triggers a Make.com workflow. The workflow fetches the product description, retrieves the brand's tone-of-voice guide from Google Drive, and asks Claude to generate responsive search ad headline and description variants. Output writes directly to a Google Sheet for human review before upload. The brand guide is the "Project knowledge" — it just lives in Drive instead of the Claude UI.
An n8n workflow aggregates performance data across channels at month-end, structures it as JSON, and sends it to Claude with a system prompt that instructs it to write a plain-English executive summary using the client's specific reporting template injected as context. The output goes into a Google Doc. What previously took 90 minutes of human time now takes under 3 minutes (QA and send).
https://api.anthropic.com/v1/messages with your API key in headers. Test with a hardcoded system prompt first to confirm the connection before adding dynamic retrieval.It's a reasonable expectation. Anthropic has steadily expanded the API surface area — adding file uploads, extended context, and tool use improvements — and a programmatic Project endpoint would follow that pattern. When it arrives, it will likely let you create and reference Projects by ID. Until then, the DIY approach outlined here is more production-ready: you own your storage, prompts, and conversation history without depending on Anthropic's UI decisions. Watch the Anthropic API changelog for announcements.
Yes, but it's manageable. A typical system prompt of 200–500 words adds a predictable per-call token cost. The bigger cost driver is injecting large document libraries on every call regardless of relevance. Retrieve only the documents needed for each specific task, and you'll keep token usage lean. For single-shot workflows, the cost difference versus a hypothetical Projects API endpoint would be negligible.
Yes — this is one of the advantages of the external storage approach. Store your system prompt in a centralized location (a specific Data Store record, a named Google Sheet cell, or a database row) and have every scenario that needs that "Project" retrieve it from the same source. When you update the prompt in one place, all scenarios that reference it pick up the change on their next run.
The HTTP module approach described here is a direct API integration — your automation tool calls Anthropic's Messages API and handles all orchestration logic itself. MCP (Model Context Protocol) is a separate layer that lets Claude proactively connect to external tools and data sources during a conversation. [5] For event-triggered batch workflows, the direct API approach is simpler. MCP makes more sense when you want Claude to autonomously decide which tools to call mid-task — learn more about using Buddy from Claude via MCP.
It depends on task complexity and latency requirements. For structured output tasks like ad copy generation or performance analysis, a mid-tier model often delivers the same quality as the largest model at lower cost and faster response times. Test the smallest model that produces acceptable output for your specific task — then move up only if quality falls short. Always pin a specific model version in your API calls so a model update doesn't silently change your workflow's behavior.
Only with proper approval gates. In production agents I build — including fully automated business workflows — Claude generates recommendations or drafts actions, but a human approval step sits between analysis and any live account change. Fully autonomous execution (Claude writes and pushes changes directly) is possible but requires rigorous testing and guardrails. Review how Buddy handles approvals and safety for a concrete example of this pattern.
More answers in this topic: Automation & Scripts