Claude API Webhook Automation for Small Business in 10 Minutes

Last January, a property inquiry came in at 11:47 PM from a German buyer interested in a quinta near Câmara de Lobos. By 7:30 AM the next morning, that lead had already received a personalized response with property details, market context for the area, and a suggested viewing schedule — all without me touching my phone. I was asleep. Claude’s API, wired to a webhook, handled the entire first contact.

If you run a solo or small business operation and you’re still manually responding to every form submission, email trigger, or CRM event, you’re leaving serious time on the table. Claude’s API combined with webhook automation is one of the most practical setups I’ve built in the past two years. This tutorial walks you through exactly how to set it up — specific steps, exact settings, real prompts — so you can replicate it for your own business.

What You’ll Build (and What It Actually Does)

By the end of this tutorial, you’ll have a working automation that:

• Catches an inbound webhook trigger (from a contact form, CRM, or scheduling tool)
• Passes the lead data to Claude’s API with a custom system prompt
• Gets back a personalized, context-aware response drafted by Claude
• Delivers that response via email or logs it in your CRM

I built this using Make.com (formerly Integromat) as the automation layer and Claude’s API directly via HTTP module. You can adapt the same logic to n8n or Pipedream if you prefer self-hosted or different pricing structures.

Prerequisites Before You Start

• Anthropic API key — Sign up at console.anthropic.com. You’ll need to add a payment method. API costs for this workflow run roughly $2–$6/month for a small business volume (under 500 calls/month using claude-3-5-haiku).
• Make.com account — Free plan works to test; the Core plan at $9/month gives you enough operations for real business use.
• A webhook source — This could be Typeform, Tally, your WordPress contact form via WPForms, or even a CRM like HubSpot. Any tool that can send a POST request with JSON data works.
• Basic JSON comfort — You don’t need to code, but knowing that {"name": "João", "email": "j@mail.com"} is a JSON object will save you confusion.

Step 1: Generate Your Anthropic API Key

Go to console.anthropic.com/settings/keys and click Create Key. Name it something specific — I call mine “make-webhook-realestate” so I know exactly what it’s attached to. Copy the key immediately. Anthropic only shows it once.

Set a usage limit under Billing → Usage Limits. For testing, I cap new keys at $10/month. This prevents any runaway loops from costing you money while you’re building.

Step 2: Create Your Make.com Scenario with a Webhook Trigger

In Make.com, click Create a new scenario. Add your first module by searching for Webhooks and selecting Custom Webhook. Click Add, name it (e.g., “Lead Intake”), and Make will generate a unique webhook URL that looks like this:

https://hook.eu1.make.com/abc123xyz456

Copy that URL. Go into your contact form tool (Tally, WPForms, Typeform, etc.) and paste it as the webhook destination. Most form tools have a direct webhook integration in their settings under “Integrations” or “Notifications.”

Back in Make, click Run once and submit a test form entry. Make will capture the incoming data structure. Once it says “Successfully determined,” you’ll see all your form fields mapped as variables you can reference in later steps.

Step 3: Add the HTTP Module to Call Claude’s API

Add a second module: search for HTTP and select Make a Request. This is where you configure the direct Claude API call. Fill in the fields exactly like this:

• URL: https://api.anthropic.com/v1/messages
• Method: POST
• Headers: Add two headers:
  • x-api-key → your Anthropic API key
  • anthropic-version → 2023-06-01
  • content-type → application/json
• Body type: Raw
• Content type: JSON (application/json)

In the Request content field, paste your JSON body. Here’s the structure I use, with Make variable references in double curly braces:

{
  "model": "claude-3-5-haiku-20241022",
  "max_tokens": 1024,
  "system": "You are a professional real estate assistant for a boutique agency in Madeira, Portugal. You write personalized, warm, and informative responses to property inquiries. Always write in the language the lead used. Be specific about Madeira's property market when relevant. Do not use generic templates — reference the specific details the lead provided.",
  "messages": [
    {
      "role": "user",
      "content": "Write a first-response email to this property inquiry:nnName: {{1.name}}nEmail: {{1.email}}nMessage: {{1.message}}nProperty interest: {{1.property_type}}nBudget: {{1.budget}}nnDraft a reply I can send within 10 minutes of receiving this. Keep it under 200 words, professional but not stiff, and suggest one next step."
    }
  ]
}

The {{1.name}} references pull directly from your webhook data captured in Step 2. Replace the field names to match whatever your form sends.

Step 4: Parse Claude’s Response in Make

Claude returns a JSON response. The actual text lives inside a nested structure. Add a third module: JSON → Parse JSON. In the JSON string field, map it to the body output from your HTTP module: {{2.data}}.

After parsing, the drafted email text will be accessible at this path:

{{3.content[].text}}

Run your scenario once with a test webhook payload to confirm the text is coming through correctly before wiring up the next step.

Step 5: Deliver the Output — Email, CRM, or Both

Now you route Claude’s drafted text somewhere useful. Three options I’ve used:

Option A: Send via Gmail or Outlook

Add a Gmail → Send an Email module (or Microsoft 365 equivalent). Set:

• To: Your own email address (so you review before sending — I strongly recommend this for a first deployment)
• Subject: Draft Reply → {{1.name}} | {{1.property_type}}
• Body: {{3.content[].text}}

This sends you a ready-to-use draft that you can review and forward in 30 seconds. I ran this setup for 6 weeks before I felt confident enough to have it send directly to leads.

Option B: Log to Notion or Airtable

If you want a paper trail, add a Notion → Create a Database Item module and log the lead’s name, inquiry date, budget, and Claude’s draft response as fields. This gives you a searchable record of every lead and the AI response generated for them.

Option C: Push Directly to Your CRM

If you use HubSpot, add a HubSpot → Create or Update Contact module, then a Create Note module with Claude’s text as the note body. Your sales pipeline gets enriched automatically with the drafted reply attached to the contact record.

Step 6: Activate and Monitor Your First 48 Hours

Turn on the scenario using the toggle at the bottom of Make’s scenario editor. Set the scheduling to Immediately (trigger runs as soon as webhook data arrives, not on a timer).

For the first 48 hours, check the History tab in Make after each run. You’ll see exactly what came in, what was sent to Claude, and what came back. If a run fails, the error message tells you exactly which module broke and why — usually a missing field reference or a JSON formatting issue in your request body.

Prompt Templates for Different Small Business Use Cases

The system prompt and user message are where most of the customization lives. Here are three templates adapted from setups I’ve shared with other solo operators:

For a Service Business (Consulting, Agency)

{
  "system": "You are a professional assistant for a boutique consulting firm. Write concise, confident responses to new client inquiries. Match the tone of the inquiry — if they're formal, be formal. Always end with a clear call to action.",
  "messages": [{
    "role": "user", 
    "content": "Draft a reply to this inquiry:nName: {{name}}nService needed: {{service}}nMessage: {{message}}nTimeline: {{timeline}}nnKeep it under 150 words. Suggest a 20-minute discovery call."
  }]
}

For an E-commerce Store (Post-Purchase Follow-Up)

{
  "system": "You write warm, helpful post-purchase emails for an online store. Be friendly and specific. Reference the product ordered.",
  "messages": [{
    "role": "user",
    "content": "Write a follow-up email for:nCustomer: {{customer_name}}nProduct ordered: {{product_name}}nOrder date: {{order_date}}nnThank them, set expectations for delivery, and ask one question about what they plan to use the product for. Under 120 words."
  }]
}

For Real Estate (What I Actually Use)

{
  "system": "You are a real estate assistant based in Madeira, Portugal. You write in the language the lead used. You know the local market well — mention specific areas when relevant (Funchal, Câmara de Lobos, Calheta, Santa Cruz). Never use generic phrases like 'dream home.' Be direct and helpful.",
  "messages": [{
    "role": "user",
    "content": "Draft a first-contact email for:nName: {{name}}nLanguage preference: {{language}}nProperty type: {{property_type}}nBudget range: {{budget}}nMessage: {{inquiry_message}}nnUnder 200 words. Suggest a video call or in-person viewing. Reference one relevant aspect of the Madeira market."
  }]
}

Tool Comparison: Running Claude via Webhook vs. Other Approaches

Approach	Setup Complexity	Monthly Cost (Low Volume)	Claude Model Access	Best For
Claude API + Make.com (this tutorial)	Medium (2–3 hours first time)	$9–$15 total	Full — all models	Solo operators, small teams
Claude API + n8n (self-hosted)	High (requires server setup)	$5–$10 (VPS) + API	Full — all models	Technical users, privacy-first
Claude.ai + Zapier (no-code)	Low	$19–$49 (Zapier alone)	Limited via third-party	Non-technical users
Claude API + Pipedream	Medium-High	Free tier available	Full — all models	Developers comfortable with JS
Pre-built AI email tools (e.g., Lavender)	Very Low	$29–$59	None (own model)	Sales teams, generic outreach

My Real-World Experience Running This in Madeira

I’ve been running a version of this webhook-to-Claude pipeline since April 2024, and the numbers are clear enough that I’m not going back.

Before I built this, every new property inquiry meant sitting down to write a first-response email. On a slow week, that’s maybe 4 or 5 emails. On a busy week — especially during peak season from May through September — I’d get 15 to 20 new inquiries, sometimes more after a listing went up on Idealista or Casa Sapo. Each email took me 10 to 20 minutes to write properly if I was doing it right: checking the lead’s language, referencing their budget, making a relevant point about the specific area they mentioned. At 15 emails a week at 15 minutes each, that’s nearly 4 hours every week spent on first-contact responses.

Since setting up this automation, that time is down to about 25 minutes a week. I still review every draft before it goes to a lead — that was a deliberate choice I made after the first 6 weeks — but reviewing and hitting send takes roughly 90 seconds per email rather than 15 minutes. Over the summer of 2024, I processed 214 inquiries through this pipeline. I edited Claude’s draft on about 40% of them, usually just to adjust a specific detail or swap in a property reference I knew better. The other 60% went out almost exactly as written.

The most useful part wasn’t even the time saving. It was the consistency. In July 2024, I was dealing with a complicated transaction that consumed most of my focus for two weeks. During that period, every single inquiry still got a thoughtful, personalized first response within minutes of submitting the form. One buyer from the Netherlands later told me the speed of my response was one of the reasons he chose to work with me over two other agents he’d contacted. That transaction closed at €485,000. The webhook automation cost me about €4 in API calls that month.

I use the claude-3-5-haiku-20241022 model for this specific workflow because the cost-per-call is low and the output quality for first-contact emails is genuinely good. For longer, more nuanced deliverables — market analysis reports, property descriptions — I switch to Sonnet, which costs more but the quality difference justifies it. For this webhook use case, Haiku is the right call.

One thing I learned the hard way: always log every API call. I added a Notion logging step after a scenario error in August 2024 caused 11 inquiries to silently fail — Claude was called, produced a response, but a broken Gmail connection meant nothing was delivered and I never got alerted. Now I log every run to a Notion database regardless of success or failure, and I get a Make.com error notification via email if any step fails.

Where This Approach Falls Short

I want to be direct about the limitations I’ve run into, because they’re real.

Claude has no memory between calls. Each webhook trigger is a fresh API call with zero context about previous interactions with that lead. If the same person has emailed you three times and submits the form again, Claude doesn’t know that. You’d need to pull their conversation history from your CRM and inject it into the prompt manually — which is doable but adds complexity.

Claude’s API occasionally times out under load. Make.com has a 40-second timeout for HTTP modules. On rare occasions — maybe once every 150–200 calls — Claude takes too long and the module fails. The scenario logs the error, but you need a fallback notification so you catch it.

The prompt needs maintenance.