How Automation Workflows Really Work: JSON and Nodes in n8n, Claude Skills & Connectors, and Apify Web Data

Short answer

1JSON: the language every automation speaks

JSON (JavaScript Object Notation) is a lightweight, text-based and language-independent format for exchanging data. It is defined by two matching standards: IETF RFC 8259 and ECMA-404.^[1][2] JSON has only two ways to structure data: objects (named fields in curly braces) and arrays (ordered lists in square brackets). Inside them you find four basic value types: strings, numbers, true/false and null.^[1]

{
  "name": "Sami Ben Ali",
  "email": "sami@example.com",
  "city": "Sousse",
  "newsletter": true,
  "orders": [ { "id": 1042, "total": 89.5 } ]
}

Why does this matter? Most web APIs exchange JSON over HTTP. HTTP is the protocol your browser uses; it defines methods such as GET (read) and POST (send) and how requests and responses are structured.^[3] The REST style that most of these APIs follow was described by Roy Fielding in his doctoral thesis.^[4] So when an automation tool “connects” to Gmail, a CRM or Google Sheets, it really sends an HTTP request and gets JSON back. Once you can read JSON, you can read every automation.

2How an n8n workflow works: triggers, nodes, connections and items

n8n defines a workflow as a collection of nodes connected together to automate a process.^[5] Four building blocks explain everything that happens on the canvas.

Nodes: one job each

A node is an entry point for retrieving data, a function to process data, or an exit for sending data.^[6] n8n distinguishes two families:^[6]

• Trigger nodes start a workflow when something happens: a time of day (Schedule Trigger),^[7] an incoming HTTP call from another app (Webhook),^[8] a new email (Email Trigger IMAP)^[9] or a new article in an RSS feed.^[10]
• Action nodes do a task: read or write data in an app, transform data, or call any API through the generic HTTP Request node.^[11]

Connections: the arrows

A connection links two nodes and routes data through the workflow: the output of one node becomes the input of the next.^[12] The arrows you draw are the order of execution.

Items: the JSON that travels along the arrows

This is the part most tutorials skip. In n8n, all data passed between nodes is an array of objects. Each object is an item, and its regular data sits under a json key; files such as PDFs or images sit under a binary key.^[13]

[
  { "json": { "name": "Sami", "email": "sami@example.com" } },
  { "json": { "name": "Ines", "email": "ines@example.com" } }
]

When a node receives several items, it runs its operation once per item automatically.^[13] That's why you don't need loops for most tasks: send 50 leads into a “Send email” node and it sends 50 emails.

Expressions: reading data from earlier nodes

To use a value inside a node's settings, n8n uses expressions written between double curly braces, such as {{ $json.email }}, which reads the email field of the current item.^[14] Expressions are small pieces of JavaScript, so you can also format dates or do simple maths in place.^[14]

The workflow itself is JSON too

n8n saves every workflow in JSON format, and you can export it or import it as a file.^[15] Open an exported file and you find two main parts: a nodes list (what each node is and how it's configured) and a connections object (which node feeds which).

{
  "name": "Daily price check",
  "nodes": [
    { "name": "Every morning", "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": { "rule": { "interval": [ { "triggerAtHour": 8 } ] } } },
    { "name": "Get prices", "type": "n8n-nodes-base.httpRequest",
      "parameters": { "method": "GET", "url": "https://api.example.com/prices" } }
  ],
  "connections": {
    "Every morning": { "main": [ [ { "node": "Get prices", "type": "main", "index": 0 } ] ] }
  }
}

3A real example, step by step

Here is a workflow we often build for small businesses: “When someone fills in the contact form on the website, save the lead, check its company website and alert the sales team.”

1. Webhook (trigger): the website form sends a POST request with the visitor's data. n8n turns it into one item: {"json": {"name": "...", "email": "...", "website": "..."}}.^[8]
2. HTTP Request: fetches the lead's website using {{ $json.website }} as the URL.^[11][14]
3. HTML node: pulls out the page title and description with CSS selectors and adds them to the item.^[16]
4. Google Sheets / CRM node: appends a row with the enriched lead.
5. Slack or email node: sends the sales team a message built from the same JSON fields.

Each step only reads JSON in and writes JSON out. That's the whole secret: if you know the shape of the JSON at each arrow, you can debug any workflow by clicking a node and reading its input and output panels.

4Claude skills and connectors: the same job, decided by AI

AI assistants such as Claude automate tasks with the same raw materials (HTTP, APIs and JSON), but the order of steps is decided by the model instead of being drawn on a canvas.

Tools: a node described in JSON Schema

With tool use (also called function calling), a developer describes each tool with a name, a plain-language description and an input_schema, which is a JSON Schema listing the fields the tool needs.^[17][18] When Claude decides a tool is needed, it doesn't run anything itself: it returns a tool_use block containing the tool name and a JSON input, the application executes it, and sends the result back as a tool_result.^[17]

{
  "type": "tool_use",
  "name": "get_weather",
  "input": { "location": "Sousse, Tunisia" }
}

Compare that with an n8n item: it's the same idea, a JSON object handed to a piece of code that does one job.

Connectors: the Model Context Protocol (MCP)

Writing a custom integration for every app and every AI assistant doesn't scale. Anthropic introduced the Model Context Protocol (MCP) in November 2024 as an open standard for connecting AI assistants to the systems where data lives, replacing those fragmented one-off integrations.^[19] The MCP documentation compares it to a USB-C port for AI applications: one standard plug for many tools.^[20]

Technically, MCP messages are JSON-RPC 2.0 messages, which means plain JSON again. The protocol has three roles: the host (the AI app, such as Claude), the client (the connector inside it) and the server (the service that offers capabilities). A server can expose tools (functions the model can run), resources (data) and prompts (templates).^[21] When you enable a “connector” for Gmail, Google Drive or a CRM in Claude, you are connecting it to an MCP server for that service. Access to user accounts is usually granted with OAuth, the standard that lets an app act for you without seeing your password.^[22]

Skills: the instructions that tie tools together

A connector gives Claude abilities; a skill gives it know-how. Anthropic defines an Agent Skill as a folder containing a SKILL.md file with instructions, plus optional scripts and resources. The file starts with a short name and description, so Claude only loads the full instructions when a task needs them (“progressive disclosure”).^[23][24] Skills can also bundle scripts that Claude runs for deterministic steps, which is more reliable than generating the same logic each time.^[23] In practice, a skill plays the role of the workflow diagram: “first fetch the invoices, then fill in the sheet, then email the summary”.

n8n vs Claude: side by side

5How Apify turns any website into JSON

Many websites you'd like to automate (competitors' prices, directories, job boards, Google Maps listings, news sites) have no public API. Apify is a platform for exactly this gap.

Actors: JSON in, JSON out

Apify's programs are called Actors: serverless cloud programs that take a structured JSON input, perform a task such as web scraping or browser automation, and produce structured output.^[27] The results of a run are stored in a dataset, a table-like storage where each scraped page or product is one record that you can export as JSON, CSV, Excel and other formats.^[28]

For example, the Website Content Crawler Actor crawls a site and returns the text of each page as clean text or Markdown, which is ideal for feeding AI chatbots and RAG systems. It can use a headless browser for JavaScript-heavy sites or plain HTTP for speed.^[29] Its input is a small JSON object:

{
  "startUrls": [ { "url": "https://www.example.com/blog" } ],
  "maxCrawlPages": 20,
  "respectRobotsTxtFile": true
}

And the output is a list of JSON records, one per page, with fields such as the page URL, its text or Markdown and its metadata.^[29]

Calling Apify from n8n: two ways

1. The Apify node (Apify's own community node, @apify/n8n-nodes-apify) can run an Actor, fetch dataset items, and trigger a workflow when an Actor run finishes. It connects with an API token or, on n8n Cloud, with OAuth2.^[30]
2. A single HTTP Request node. Apify's API has an endpoint that runs an Actor and returns its dataset items in the same response: POST https://api.apify.com/v2/actors/<actorId>/run-sync-get-dataset-items. The JSON body you send becomes the Actor's input, and the response is the scraped data. The synchronous call waits up to 300 seconds; longer jobs should run asynchronously.^[31]

Apify also runs an MCP server, so Claude and other AI assistants can search for and run Apify Actors directly as tools.^[33] Again, the same plumbing: JSON input, JSON output, a tool in the middle.

Scrape responsibly

Being technically able to read a page doesn't mean every use is allowed. Respect the site's robots.txt rules, the standard way sites tell automated clients which paths they may access,^[34] read the site's terms of use, and limit how fast you crawl. If you collect information about people, such as names, emails or profiles, data-protection laws like the EU's GDPR apply, including the need for a lawful basis for processing.^[35]

6When a tool has no API: the alternatives

An API (application programming interface) is the official door a software product opens for other programs. Automation is easiest and most reliable through it: n8n's HTTP Request node can call any REST API, even when there is no ready-made node for that service.^[11] But many tools, especially older, local or niche software, don't offer one. Here are the alternatives, from the most reliable to the most fragile.

1. Webhooks and push notifications

Some tools have no full API but can still send a notification to a URL when something happens. n8n's Webhook node gives you that URL.^[8] The W3C's WebSub standard describes this publish-and-subscribe pattern for the web.^[36]

2. RSS feeds

Blogs, news sites, job boards and many platforms still publish RSS, a standard XML feed of their latest items.^[37] n8n's RSS Feed Trigger starts a workflow whenever a new item appears.^[10]

3. Email as the integration

Almost every tool can send emails: order confirmations, reports, alerts and CSV exports. n8n's Email Trigger (IMAP) watches a mailbox and starts a workflow for each new message,^[9] and attachments arrive as binary data you can process in the next nodes.^[13] A dedicated inbox per automation keeps this clean.

4. Fetching and parsing the HTML

If the information is visible on a simple web page, an HTTP Request node can download the page and the HTML node can extract parts of it with CSS selectors.^[11][16] This works for static pages but breaks when the content is built by JavaScript.

5. Scraping platforms (Apify)

For JavaScript-heavy sites, many pages, pagination, or sites that change often, use a managed scraper. Apify Actors handle browsers, retries and storage for you, and return a JSON dataset (see section 5).^[27][29]

6. Browser automation

When you need to act on a website (log in to your own account, fill in forms, download a report) you can script a real browser. Microsoft's open-source Playwright drives the three main browser engines, Chromium, Firefox and WebKit, with or without a visible window.^[38] The script follows the same clicks a person would do.

7. RPA: robots that use the screen

Robotic Process Automation (RPA) automates desktop software through its user interface, the way an employee would. Researchers describe it as an “outside-in” approach: the existing system stays unchanged, and software robots work on top of it, which suits repetitive, rule-based tasks in legacy systems that have no API.^[39]

8. AI computer use

The newest option is to let an AI model operate a computer. Claude's computer use tool lets the model take screenshots and control the mouse and keyboard to complete tasks in a desktop environment.^[40] Unlike classic RPA, it can adapt when a button moves. Anthropic's documentation insists on safeguards: run it in a dedicated virtual machine or container, don't give it sensitive data, limit internet access, and require human confirmation for consequential actions, because content on a screen can try to hijack the model's instructions (prompt injection).^[40]

7How to choose the right method

1. Write the task as data: what JSON comes in, and what JSON should come out? If you can't describe it, it isn't ready to automate.
2. Look for the official door: a native n8n node, a public API callable with the HTTP Request node,^[11] or an MCP server for Claude.^[20]
3. No API? Go down the list above: webhook, RSS, email, then scraping or browser automation.
4. Fixed steps or judgement? Repeated, predictable steps belong in an n8n workflow; tasks that need reading, writing or decisions suit Claude with skills and connectors. Many businesses use both.
5. Protect the data: keep tokens in credentials, never in URLs,^[32] and respect privacy law when you handle personal data.^[35]

Automation also helps your visibility work. Our guide The SEO & GEO audit prompt shows how an AI assistant can audit a site, and From Keywords to Vectors explains how AI search engines retrieve content, often from the same kind of crawled JSON described above.