Connecting Apps in n8n — The Big Picture

In n8n, every workflow starts with a trigger (a node that kicks things off) and continues with action nodes that talk to other services. To make two apps talk to each other, you need three things: a credential (so n8n is allowed to access the app), the right node type for that service, and an understanding of how data is shaped when it moves between nodes.

n8n passes data between nodes as JSON objects. Each node receives an array of items, does something with them, and passes a new array forward. This consistent structure is what lets you chain almost any two apps together without writing glue code.

Credentials and Picking the Right Node

Before n8n can read from or write to an external app, you must add a credential. Go to the left sidebar, click Credentials, create a new one, and choose the app type (for example, Google Sheets OAuth2, Slack API token, or Airtable PAT). Once saved, every node of that type in your workflows can reuse it.

Each app in n8n usually offers several nodes. For Google Sheets you have a single "Google Sheets" node with multiple operations (read rows, append row, update row). For CRMs or marketing tools you often see one node per resource. Picking the right node is mostly about matching the operation you need: read vs. write vs. update.

// Example: a credential reference shown in an n8n node (conceptual)
{
  "node": "Google Sheets",
  "operation": "readRows",
  "credential": "Google Sheets account 1",
  "sheetId": "1AbC...",
  "range": "A1:D100"
}

Mapping Fields Between Services

Different apps name the same concept differently. A customer in Stripe is `customer.email`; in HubSpot it is `properties.email`; in a Google Sheet it might be column `Email`. When you drag the output of one node into the input field of another, n8n builds an **expression** that pulls the value from the previous item's JSON.

You can write expressions manually using the n8n expression syntax, which wraps references in `{{ }}`. For example, to pull an email from a previous node called "Stripe Trigger":

{{ $json.customer.email }}

To grab a value from a specific named node further upstream (useful when the previous node is a Set or Filter):

{{ $node["HTTP Request"].json["body"]["title"] }}

This referencing system is the core of mapping fields across services.

Transforming Data with the Set and Code Nodes

Sometimes the data you receive does not match what the next app expects. You may need to rename keys, combine fields, drop empty values, or compute a new field. The **Set** node handles simple cases — rename, keep only certain keys, or add new static or expression-based fields.

// Set node "Edit Fields" configuration (conceptual)
{
  "values": {
    "string": [
      { "name": "fullName", "value": "{{ $json.firstName }} {{ $json.lastName }}" },
      { "name": "email",    "value": "{{ $json.email }}" }
    ]
  },
  "options": { "keepOnlySet": true }
}

When you need loops, conditionals, or any real logic, drop in a **Code** node. It runs JavaScript or Python on every input item and returns a new array.

// Code node (JavaScript mode) — keep only paying customers
const items = $input.all();
return items.map(item => {
  if (item.json.plan !== 'free') {
    return { json: { id: item.json.id, email: item.json.email } };
  }
  return null;
}).filter(Boolean);

The Code node is the escape hatch when expressions and the Set node are not enough.

Real-World Example: Stripe Payment to Slack Notification

Imagine you want to post a Slack message every time a new paying customer appears in Stripe. The flow has four nodes: Stripe Trigger (on new customer) → Set (reshape the data) → Code (filter to paying plans) → Slack (post message). The Set node builds a friendly message string, the Code node drops free-plan customers, and the Slack node sends a formatted block to a channel.

// Slack node "message" field, built from the Set node output
{{ $json.greeting }} — new paying customer!
Email: {{ $json.email }}
Plan: {{ $json.plan }}

Common Mistakes and Quick Fixes

The most frequent error is referencing a field that does not exist on the incoming item — n8n will silently output `undefined`. Always open the previous node's output panel and inspect the JSON shape before wiring expressions. Another trap is forgetting that n8n data is an **array of items**, not a single object, so `$json` refers to the first item and `$input.all()` returns the whole array. Finally, watch out for rate limits: many apps (Slack, Google Sheets, HubSpot) throttle bursts, so add a **Wait** node or split batches when syncing large datasets.

Summary

Connecting apps in n8n is about three skills: adding the right credential and node, mapping fields with expressions, and reshaping data with Set or Code nodes when the shapes do not line up. Master those, and almost any two business apps can exchange data without custom code.