n8n (pronounced "n-eight-n") is an open-source automation tool that lets you connect hundreds of services and APIs without writing complex code. Unlike tools such as Zapier that are SaaS-only, n8n offers two options: using their managed Cloud, or Self-Hosting — running n8n on your own server. Self-Hosting means zero cost per execution, full control over the data and no limit on the number of executions.

n8n's power lies in its conceptual simplicity: every Workflow is built from Nodes connected to each other. Each Node receives data, processes it, and passes the result to the next Node. The data flows in JSON format — meaning each Node sees an array of Items and can act on each Item separately. This is the basis that lets you process thousands of records in a single automation.

Trigger types — what starts the Workflow?

Every Workflow starts with a Trigger Node — the component that decides when the flow runs. There are three main types. Webhook Trigger — n8n creates a unique URL; when someone sends an HTTP request to that address, the Workflow starts immediately. This is perfect for connecting with external services, lead forms or GitHub Events. Schedule Trigger (Cron) — the Workflow runs on a schedule: every hour, every morning at 7:00, every Sunday. Precise and reliable, perfect for daily reports and data updates. Manual Trigger — manual execution for testing and development.

HTTP Request Node — the universal connector

The HTTP Request Node is the most powerful tool in n8n. It lets you send GET, POST, PUT, DELETE requests to any API in the world. No dedicated Node for Anthropic Claude? No problem — the HTTP Request Node covers everything. Configuring the Node includes: Method (GET/POST/...), URL, Headers (including Authorization), and a Body in JSON format. When the API returns JSON, n8n parses it automatically and lets you access the fields directly in the following Nodes.

For error handling, n8n offers two main mechanisms. In Node Settings you can enable "Continue on Fail" — in case of an error the Workflow continues to process the rest of the Items. Right-clicking a Node gives access to "Add Error Handler" which adds a dedicated branch for error handling — failed Items go there, and you can log them to a Spreadsheet, send a Slack alert or retry.

• n8n Cloud — a free plan with 5 active workflows and 5,000 executions per month
• Self-Hosted — no limits, installed on Docker in minutes
• Each Node receives and returns an array of Items in JSON format
• Expressions let you access data from previous Nodes with a simple syntax
• The n8n Code Node lets you run JavaScript for complex data processing

{
  "method": "POST",
  "url": "https://api.anthropic.com/v1/messages",
  "authentication": "genericCredentialType",
  "headers": {
    "x-api-key": "={{ $credentials.anthropicApiKey }}",
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
  },
  "body": {
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 512,
    "system": "Respond in JSON only.",
    "messages": [
      {
        "role": "user",
        "content": "={{ $json.user_message }}"
      }
    ]
  },
  "options": {
    "retry": { "enabled": true, "maxAttempts": 3 }
  }
}

Connecting an AI model into a Workflow is not magic — it is an HTTP Request with JSON. Every leading AI model exposes a REST API that receives a POST request with instructions and returns text. Once you understand the basic structure, you can connect any AI model to any Workflow within minutes.

Claude API — Messages Array and System Prompt

Anthropic's Claude API is built around a structure Messages — an array of messages that represent the conversation. Each message includes role (user/assistant) and content (the text). The System Prompt is a global instruction that defines the AI's character — what it knows, how it behaves, in which language it answers and what format it returns. For automations, the System Prompt is very important: "always respond only in JSON, with no additional text" — a simple instruction that prevents parsing errors in the following steps.

Parameter max_tokens Controls the maximum response size. For classification and sorting — 256 tokens are enough. For summaries — 512–1024. For writing long content — 4096+. Managing max_tokens this correctly is cost management: Claude 3.5 Haiku is 10x cheaper than Sonnet, and for simple classification tasks — Haiku is entirely enough.

GPT-4o via OpenAI API

The OpenAI API is similar in structure to Claude: Messages Array, System Prompt, max_tokens. The main difference is in Function Calling — OpenAI lets you define functions the AI can "decide" to call when the user requests an action. For example: a function get_weather(city) is defined. The user writes "What is the weather in Tel Aviv?". The API returns a request to call get_weather with city="Tel Aviv". The Workflow detects the call, invokes the real Weather API, and returns the result to GPT to continue the response.

For cost management in a production environment: use Claude's Prompt Caching (keeping a fixed System Prompt) to cut costs by up to 90% on repeated requests. In OpenAI, always set a Seed for consistent results in tests. Add a Timeout to HTTP Request Nodes — a 30-second Timeout prevents Workflows from getting stuck due to a slow API.

// POST https://api.anthropic.com/v1/messages
{
  "model": "claude-3-5-haiku-20241022",
  "max_tokens": 256,
  "system": "You are an email classifier. Always respond with valid JSON only. No additional text.\n\nJSON schema: {\"category\": \"sales|support|billing|spam|internal\", \"urgency\": \"low|medium|high\", \"action\": \"reply|forward|archive|escalate\", \"summary\": \"string max 60 chars\"}",
  "messages": [
    {
      "role": "user",
      "content": "Classify this email:\n\nFrom: {{ $json.from }}\nSubject: {{ $json.subject }}\n\n{{ $json.body_preview }}"
    }
  ]
}

// response from Claude:
// {
//   "content": [
//     {
//       "type": "text",
//       "text": "{\"category\": \"support\", \"urgency\": \"high\", \"action\": \"escalate\", \"summary\": \"Customer reports a serious technical issue\"}"
//     }
//   ]
// }
//
// extraction in n8n: {{ JSON.parse($json.content[0].text) }}

• Prompt Engineering for automations: always request JSON, always define a clear Schema
• System Prompt Caching in Claude saves up to 90% of input Token cost
• Gemini Flash 2.0 — the cheapest option for high-volume classification
• Fallback Strategy: if Claude fails → try OpenAI → if it fails → save to a manual queue
• Always check the usage field in the response to monitor Token Consumption

Automation without organized data is like a machine with no raw material. In most projects, the data lives in several places at once: Google Sheets for reports and a non-technical team, Airtable for structured data with views and relations, Notion for knowledge and task management. The challenge is to make them all talk to each other — and that is where automation comes in.

Google Sheets as a Database for automations

Google Sheets is not just a Spreadsheet — for small teams it can serve as a simple and effective Database. n8n and Make.com have dedicated Nodes for Sheets that allow reading, writing and updating rows. The common approach: save the Row ID (row number) in the Workflow to update a specific row without scanning the entire Sheet. It is better to add a unique ID column (for example Email or UUID) and search by it instead of by a row number that changes.

Airtable adds a layer of capabilities beyond Sheets: Records with a fixed ID that does not change, Relations between Tables, Formula Fields that compute values automatically, and Views that display the same data in different ways. The RESTful Airtable API allows Upsert (update if it exists, add if it is new) — a Pattern critical for automations that run repeatedly on the same Dataset.

Notion for knowledge and task management

The Notion API lets you create new Pages, update Properties of Database Records, and add Blocks (content) into existing Pages. A common use: every new meeting in the CRM → an automatic Notion Page with a Meeting Notes template + Properties like Company, Owner, Stage. After the meeting, an AI summarizes the notes and adds a Summary Block to that Page automatically.

// step 1: search by Email
// GET https://api.airtable.com/v0/{baseId}/{tableId}
// Query: filterByFormula=({Email}="{{ $json.email }}")

// step 2 (IF Node): was a row found?
// IF records.length > 0 → Update
// ELSE → Create

// Update Record:
// PATCH https://api.airtable.com/v0/{baseId}/{tableId}/{recordId}
{
  "fields": {
    "Last Contact": "{{ $now }}",
    "Lead Score": "{{ $json.new_score }}",
    "Stage": "{{ $json.stage }}",
    "AI Summary": "{{ $json.ai_summary }}"
  }
}

// Create Record:
// POST https://api.airtable.com/v0/{baseId}/{tableId}
{
  "fields": {
    "Name": "{{ $json.name }}",
    "Email": "{{ $json.email }}",
    "Lead Score": "{{ $json.score }}",
    "Created": "{{ $now }}",
    "Source": "{{ $json.utm_source }}"
  }
}

• Google Sheets takes 1–2 seconds per operation — not suitable for frequent Real-Time automations
• An Airtable Record ID is fixed — always save it after creation for future updates
• The Notion API limits 3 requests per second per Integration Token
• Changing Date Formats: an n8n Code Node with moment.js, or a Set Node with an expression
• For high-efficiency data — consider Supabase (PostgreSQL) instead of Sheets/Airtable