What n8n Actually Is

n8n is a workflow automation platform you run yourself. Unlike Zapier or Make, you host it on your own infrastructure, which means you control the data flow and can modify the source code if needed. It’s built on Node.js and stores workflows as JSON files.

The core concept is simple: nodes connected by lines. Each node performs one action (call an API, transform data, wait for a condition). Data flows from left to right through your workflow. When a trigger fires, n8n executes each node in sequence, passing the output of one node as the input to the next.

What makes it relevant now is the AI integration layer. n8n has native nodes for OpenAI, Anthropic, Google, and other providers. You can chain LLM calls, parse responses, and route data based on model outputs without writing custom API code. The platform handles authentication, retries, and rate limiting.

The self-hosted aspect matters more than it sounds. When you’re processing customer data through AI models, having the orchestration layer on your own infrastructure means you can audit exactly what gets sent where. You can also run it locally during development without worrying about webhook callbacks or external triggers.

n8n is written in TypeScript and uses a PostgreSQL database for execution history and credentials. The interface runs in your browser but the actual workflow execution happens server-side. This means you can close your browser and workflows keep running.

Setup and Authentication

You have three deployment options: Docker, npm, or their cloud service. For production use, Docker is the most reliable path. Here’s what actually works.

Create a docker-compose.yml file:

version: '3.8'
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: n8n
      POSTGRES_DB: n8n
    volumes:
      - postgres-data:/var/lib/postgresql/data
  n8n:
    image: n8nio/n8n
    ports:
      - "5678:5678"
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_PORT: 5432
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: n8n
      N8N_BASIC_AUTH_ACTIVE: true
      N8N_BASIC_AUTH_USER: admin
      N8N_BASIC_AUTH_PASSWORD: change_this_password
    volumes:
      - n8n-data:/home/node/.n8n
    depends_on:
      - postgres
volumes:
  postgres-data:
  n8n-data:

Run docker-compose up -d and access the interface at localhost:5678. Change the basic auth credentials immediately.

For AI model authentication, you’ll need API keys from your providers. In n8n, go to Settings > Credentials and add new credentials for each service. For OpenAI, you need an API key from platform.openai.com. For Anthropic, get one from console.anthropic.com. Store these in n8n’s credential system rather than hardcoding them in workflows.

The credential system encrypts keys at rest using an encryption key stored in your environment. Set N8N_ENCRYPTION_KEY to a random 32-character string in your docker-compose file. If you lose this key, you lose access to all stored credentials.

For production, you’ll want to set up a reverse proxy with SSL. n8n doesn’t handle HTTPS natively. Point nginx or Caddy at port 5678 and let it handle certificates. Set WEBHOOK_URL to your public domain so webhooks know where to call back.

First Working Example

Let’s build a workflow that monitors a Google Sheet, sends new rows to an AI model for analysis, and writes the results back. This covers the three core patterns: trigger, transform, write.

Create a new workflow in n8n. Add a “Google Sheets Trigger” node. You’ll need to authenticate with Google (n8n walks you through OAuth). Select your spreadsheet and the sheet name. Set the trigger to “On Row Added”.

Add an “OpenAI” node connected to the trigger. Select “Message a Model” as the operation. Choose gpt-4o as the model. In the prompt field, reference the trigger data:

Analyze this customer feedback and extract: sentiment (positive/negative/neutral), main topic, and urgency (high/medium/low).

Feedback: {{$json["feedback"]}}

Return only JSON with keys: sentiment, topic, urgency

The {{$json["feedback"]}} syntax pulls the “feedback” column from your sheet row. Test this node with sample data using the “Execute Node” button.

Add a “Code” node to parse the AI response. n8n’s AI nodes return text, so you need to extract the JSON:

const response = $input.first().json.message.content;
const parsed = JSON.parse(response);
return [{
  json: {
    sentiment: parsed.sentiment,
    topic: parsed.topic,
    urgency: parsed.urgency,
    original_feedback: $('Google Sheets Trigger').first().json.feedback
  }
}];

Finally, add a “Google Sheets” node set to “Append Row”. Map the parsed fields to columns in a results sheet. Connect all nodes in sequence.

Activate the workflow using the toggle in the top right. Add a row to your source sheet. Within seconds, you’ll see the analysis appear in your results sheet.

This pattern scales. Replace the Google Sheets trigger with a webhook for real-time processing. Swap OpenAI for Anthropic if you need longer context. Add a conditional node to route high-urgency items to a different sheet or send a Slack message.

Key Settings That Matter

The execution settings control how n8n handles failures and retries. By default, if a node fails, the entire workflow stops. For production workflows, you want different behavior.

Click the three dots on any node and select “Settings”. Under “Retry On Fail”, enable it and set retry attempts to 3 with a 5-second wait between attempts. This handles transient API failures without manual intervention.

For AI nodes specifically, set a timeout. LLM calls can hang if the provider is slow. Set “Timeout” to 30 seconds for most use cases. If you’re using long-context models or complex prompts, increase to 60 seconds.

The “Continue On Fail” setting is critical for workflows that process batches. If you’re analyzing 100 customer reviews and one fails, you don’t want the other 99 to stop. Enable this on your AI nodes and add an “Error Trigger” node to capture and log failures separately.

Workflow execution mode matters more than people realize. By default, n8n runs workflows in “main” mode, which means they execute immediately when triggered. For high-volume workflows, switch to “queue” mode in the workflow settings. This adds executions to a queue and processes them with concurrency limits you set.

The AI model temperature setting lives in the OpenAI or Anthropic node configuration. For structured extraction tasks like the example above, set temperature to 0.1. For creative tasks like generating marketing copy, use 0.7 to 0.9. The default of 0.7 is rarely optimal for either case.

Credential scoping is hidden but important. When you create credentials, you can set them to be available to all workflows or specific ones. For API keys with broad permissions, restrict them to specific workflows. This limits damage if a workflow gets misconfigured.

Where It Shines

n8n excels at orchestrating multi-step AI workflows where you need to chain different models or combine AI with traditional APIs. The visual interface makes it easy to see the data flow, which matters when you’re debugging why a prompt isn’t getting the context it needs.

Document processing pipelines are a natural fit. Trigger on new files in a folder, extract text with a PDF parser, send chunks to an LLM for summarization, store results in a database, and send a notification. Each step is a node, and you can test them individually before running the full chain.

The self-hosted aspect shines when you’re processing sensitive data. Healthcare companies use n8n to run AI analysis on patient data without sending it to a third-party automation platform. Financial services use it to analyze transactions with models running on their own infrastructure.

Integration density is a real advantage. n8n has over 400 native integrations. When you need to pull data from Salesforce, analyze it with Claude, and write results to PostgreSQL, you’re not writing three different API clients. You’re dragging three nodes onto a canvas.

The code node capability means you’re never blocked. If n8n doesn’t have a node for something, you can write JavaScript to handle it. This is common with newer AI APIs that don’t have official nodes yet. You can call any HTTP API from a code node and parse the response however you need.

Workflow versioning through JSON export is underrated. You can commit workflows to git, diff them, and roll back changes. This matters for teams where multiple people are building automations. You can review workflow changes in pull requests just like code.

Where It Fails

The learning curve is steeper than no-code tools claim. The visual interface is intuitive for simple workflows, but once you’re passing data between nodes, referencing previous outputs, and handling errors, you need to understand the expression syntax and data structure. This isn’t point-and-click automation.

Performance hits limits faster than you’d expect. n8n runs on a single Node.js process by default. For workflows that process large datasets or make many API calls, you’ll need to set up queue mode and scale horizontally. This requires additional infrastructure and configuration that isn’t documented well.

The AI nodes lag behind provider capabilities. When OpenAI or Anthropic releases a new model or feature, it takes weeks or months for n8n to add support. You can work around this with HTTP Request nodes and custom code, but then you’re not using the native integration anymore.

Error handling is verbose. When a workflow fails, the error message often points to the node that failed but not the specific line or condition that caused it. Debugging complex workflows means adding manual logging nodes to track data flow, which clutters the canvas.

The community edition lacks features that matter for production use. There’s no built-in alerting when workflows fail. No usage analytics to see which workflows are consuming resources. No role-based access control if you have a team. The enterprise version adds these, but the pricing isn’t transparent.

Local development is clunky. You can’t easily run workflows locally and then deploy them to a server. The workflow JSON files work, but credentials don’t transfer. You end up maintaining separate credential sets for dev and prod, which is error-prone.

The webhook system requires a public URL. If you’re running n8n locally or behind a firewall, you need to set up tunneling or a reverse proxy to receive webhooks. This adds complexity that other platforms handle automatically.

Practical Workflow Pattern

Here’s how n8n fits into a real business workflow. You’re running a content analysis pipeline that processes customer support tickets.

Start with a webhook trigger that your support system calls when a new ticket arrives. The webhook payload includes ticket ID, customer message, and metadata. n8n receives this and starts the workflow.

First node: call your internal API to fetch the customer’s history. Use an HTTP Request node with authentication headers. This gives context the AI needs.

Second node: format the prompt. Use a Code node to combine the current message with historical context. Structure it for the AI model you’re using. For Claude, you might format it as a conversation history. For GPT-4o, you might use a system message with context.

Third node: call the AI model. Use the native OpenAI or Anthropic node. Set temperature to 0.2 for consistent categorization. Add retry logic because API calls fail.

Fourth node: parse the response. Extract the category, sentiment, and suggested actions. Use a Code node to validate the JSON structure and handle cases where the model returns malformed data.

Fifth node: write results to your database. Use a PostgreSQL node to insert the analysis. Include the original ticket ID so you can join this data with your support system.

Sixth node: conditional routing. If the sentiment is negative and urgency is high, trigger an alert. Use an IF node to check conditions. Connect the true branch to a Slack node that notifies your support team.

Error handling: add an Error Trigger node that catches failures from any step. Log the error to a separate database table with the full context. Send a notification to your ops channel so someone can investigate.

This pattern handles thousands of tickets per day. The key is setting execution mode to queue and running multiple n8n instances behind a load balancer. Each instance processes workflows from the shared queue.

For monitoring, export execution data to your analytics platform. n8n stores execution history in PostgreSQL, so you can query it directly. Track success rates, execution times, and error patterns. Set up alerts when error rates spike.

The workflow evolves over time. You might add a node that checks if similar tickets exist and suggests responses based on past resolutions. Or add a feedback loop where support agents rate the AI suggestions and you use that data to refine prompts.

To see how tools like this fit into a complete AI operating layer for your business, book a 60-min Omni Audit at https://calendly.com/sam-mckay/discovery-call.

The real value of n8n isn’t replacing developers. It’s giving technical teams a faster way to prototype and deploy AI workflows without writing boilerplate code for authentication, retries, and error handling. You still need to understand APIs, data structures, and prompt engineering. But you spend less time on plumbing and more time on the logic that matters.