/ Blog
Home Blog Contact Buddy Ads Builder Audit Engine

Claude custom projects in the automation workflow?

Automation & Scripts

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.

Key takeaways

  • Claude Projects are a UI convenience layer — a bundled system prompt, uploaded documents, and scoped conversation history — not a distinct model capability accessible via API.
  • The Anthropic Messages API already exposes every primitive a Project uses: the system parameter for instructions, the messages array for document context, and external storage for memory.
  • Store your system prompt outside the HTTP module (in a Data Store, Google Sheet, or database) so non-technical team members can update AI behavior without touching the workflow.
  • The API approach is more production-ready than Projects for any event-triggered task; use the Projects UI only for ad-hoc, human-initiated work.
  • Version-control your system prompts from day one — a simple version log lets you roll back instantly when an update degrades output quality.
Key terms
Claude Projects
A Claude.ai UI feature that bundles a persistent system prompt, shared uploaded documents, and scoped conversation history into a single configuration — not a distinct API endpoint.
System prompt
A set of instructions passed to Claude at the start of every API call that defines its role, behavior, and output format for that request.
Stateless API
An API that retains no memory between calls — each request must supply all necessary context, including any prior conversation history, explicitly.
RAG (Retrieval-Augmented Generation)
A pattern where relevant documents are fetched from external storage and injected into the prompt at runtime, rather than baking all knowledge into the model itself.
Messages array
The structured list of conversation turns (user and assistant messages) sent to the Anthropic API; this is how you provide Claude with conversation history or document context programmatically.
---

What are Claude Projects, and why can't automation tools call them directly?

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.

Key Insight: Claude Projects are a UI convenience feature that bundles a system prompt + document context + conversation scoping. The Anthropic Messages API gives you direct access to all three primitives individually, which is actually more flexible for automation purposes.
---

How do you replicate Claude Projects inside Make.com or n8n?

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]

Step 1 — Move your Project instructions to a system prompt

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.

Common Mistake: Hardcoding your system prompt directly inside the Make.com HTTP module body makes it a maintenance nightmare. When you need to update instructions, you have to dig into the module config every time. Storing it in a Data Store or Sheet lets non-technical team members update AI behavior without touching the workflow.

Step 2 — Inject document context via the messages array

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:

  1. Store reference documents in Google Drive, Notion, or a database.
  2. Add a retrieval step in your workflow to fetch only the content relevant to the current task.
  3. Inject that content into the system prompt or as an initial user message before your main task prompt.
Best Practice: Don't inject your entire knowledge base on every call. Retrieve only documents relevant to the current task — this keeps token usage lean and costs predictable while actually improving Claude's focus. For a Google Ads agent, only pull in the account's tone-of-voice guide when generating ad copy, not when doing bid analysis.

Step 3 — Handle conversation memory with external storage

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.

---

How do you configure the HTTP module in Make.com step by step?

Make.com's generic HTTP module handles Anthropic API calls cleanly even without a native Claude connector.

  1. Method: POST
  2. URL: https://api.anthropic.com/v1/messages
  3. Headers:
    • x-api-key: your Anthropic API key (stored in Make.com secrets, never in the module body)
    • anthropic-version: 2023-06-01
    • content-type: application/json
  4. Body type: Raw / JSON
  5. Body: your JSON payload with model, max_tokens, system, and messages

To 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.

Multi-turn conversation pattern

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:

  1. Look up the existing conversation array for this session from your Data Store.
  2. Append the new user message to that array.
  3. Send the full array as the messages parameter in your API call.
  4. Parse Claude's response and append the assistant turn to the array.
  5. Save the updated array back to the Data Store.
  6. Use a router to check whether the conversation is complete or needs another turn.
---

When should you use Claude Projects versus the API in automation?

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
Key Insight: If a task is triggered by an event — a form submission, a scheduled time, a new spreadsheet row, a webhook from an ad platform — it belongs in an automation workflow with the API. If a human initiates it interactively on an ad-hoc basis, the Projects UI is genuinely the better choice.
---

What do real marketing automation workflows look like using this pattern?

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.

Google Ads performance alerts

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.

Ad copy generation at scale

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.

Monthly reporting narrative

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).

Best Practice: Version-control your system prompts. Treat them like code — store them with a version number and date column. When an update causes a regression in output quality, you can roll back immediately. A simple version log takes 2 minutes to set up and saves hours of re-engineering.
---

What to do next

  1. Extract your Project instructions. Open your existing Claude Project, copy the system prompt verbatim, and paste it into a Make.com Data Store record, a Google Sheet cell, or a Notion property. This is your portable "Project config."
  2. Set up and test the HTTP module. Point Make.com's HTTP module at 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.
  3. Map your document context. List every file uploaded to your Claude Project. Decide where each lives in your automation stack (Drive, Airtable, Data Store) and build a retrieval step that fetches relevant content before each Claude API call.
  4. Add conversation memory only if you need it. Most automation workflows are single-shot (one input → one Claude response → output to another tool). Only add conversation array management if your use case genuinely requires multi-turn dialogue in an automated context.
  5. Version your system prompts from day one. Before going to production, set up a simple log tracking prompt versions. You'll use it the first time an update breaks something that was working — and it will happen.
---

Frequently asked questions

Will Anthropic ever expose Claude Projects via API?

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.

Does injecting a system prompt on every API call significantly increase costs?

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.

Can I share a "Project config" across multiple Make.com scenarios?

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.

How is this different from using Claude's MCP integrations?

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.

What Claude model should I use in automation workflows?

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.

Is it safe to run Claude API calls that affect live ad accounts automatically?

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.

References

  1. Anthropic. “Claude Help Center.” Accessed Nov 3, 2026.
  2. Anthropic. “Intro to Claude.” Accessed Nov 3, 2026.
  3. Wikipedia. “Large language model.” Accessed Nov 3, 2026.
  4. Google for Developers. “Introduction to the Google Ads API.” Accessed Nov 3, 2026.
  5. Model Context Protocol. “What is the Model Context Protocol (MCP)?.” Accessed Nov 3, 2026.
  6. Original community discussion: r/ClaudeAI thread on Reddit.

Related Reading

AI Disclosure: This article was generated with AI assistance based on a community discussion on Reddit r/ClaudeAI. Expert analysis and practitioner perspective by John Williams, Founder, AHMEEGO · Google Ads Practitioner with $350M+ in managed Google Ads spend. AI was used to draft and structure the content; all strategic recommendations reflect real campaign experience.