HTML node

All Operations

Output Data

Generate HTML Template

One output item per input item. The rendered markup is written to html:

{
  "html": "<h1>Hello Ada!</h1><p>Your email is ada@example.com</p>"
}

With Output as Binary off, html is the only field on the item — the rest of the input JSON is dropped. With Output as Binary on, the input JSON is kept, html is added beside it, and the same markup is also written as a text/html binary file on Binary Property under File Name, alongside any binary the item already carried.

Extract HTML Content

One output item per HTML string parsed. The extracted values are added to the input item’s JSON, each under its rule’s Key:

{
  "url": "https://example.com/article",
  "headline": "Quarterly results",
  "links": ["https://example.com/a", "https://example.com/b"],
  "tags": ["finance", "reports"]
}

• A rule with Return Array on gives an array with one entry per matched element; with it off, a single value.
• A selector that matches nothing yields an empty array when Return Array is on, and an empty value when it is off — extraction never fails just because the page changed shape.
• When JSON Property points at an array of HTML strings, the node emits one output item per string, so a page-per-string crawl fans out automatically.
• Binary data is forwarded unchanged.

Convert to HTML Table

One output item for the whole node run, whatever the input count. The item JSON holds a single field:

{
  "table": "<table ...><thead>…</thead><tbody>…</tbody></table>"
}

The column headers are the union of the keys found on the input items, and nothing from the input JSON is carried onto the output item. No binary is produced — pass the result to Convert to File if you need a downloadable .html.

Example Configuration

Render a simple template from item fields:

{
  "type": "html",
  "parameters": {
    "operation": "generateHtmlTemplate",
    "html": "<h1>Hello {{ $json.name }}!</h1><p>Your email is {{ $json.email }}</p>",
    "maxConcurrency": 10
  }
}

Render a full document and save it as a downloadable file:

{
  "type": "html",
  "parameters": {
    "operation": "generateHtmlTemplate",
    "html": "<!DOCTYPE html><html><head><title>{{ $json.title }}</title></head><body><h1>{{ $json.heading }}</h1><p>{{ $json.content }}</p></body></html>",
    "outputAsBinary": true,
    "binaryPropertyName": "htmlDocument",
    "fileName": "report.html",
    "maxConcurrency": 5
  }
}

Extract a title, every link and the paragraph text from an HTML string on the item:

{
  "type": "html",
  "parameters": {
    "operation": "extractHtmlContent",
    "sourceData": "json",
    "dataPropertyName": "htmlContent",
    "extractionValues": {
      "values": [
        {
          "key": "title",
          "cssSelector": "h1",
          "returnValue": "text",
          "returnArray": false
        },
        {
          "key": "links",
          "cssSelector": "a",
          "returnValue": "attribute",
          "attribute": "href",
          "returnArray": true
        },
        {
          "key": "paragraphs",
          "cssSelector": "p",
          "returnValue": "text",
          "skipSelectors": ".exclude",
          "returnArray": true
        }
      ]
    },
    "options": {
      "trimValues": true,
      "cleanUpText": true
    }
  }
}

Extract from an uploaded HTML file instead:

{
  "type": "html",
  "parameters": {
    "operation": "extractHtmlContent",
    "sourceData": "binary",
    "dataPropertyName": "uploadedFile",
    "extractionValues": {
      "values": [
        {
          "key": "productName",
          "cssSelector": ".product-title",
          "returnValue": "text",
          "returnArray": false
        },
        {
          "key": "price",
          "cssSelector": ".price",
          "returnValue": "text",
          "returnArray": false
        }
      ]
    },
    "options": {
      "trimValues": true,
      "cleanUpText": false
    },
    "maxConcurrency": 3
  }
}

Scrape several fields out of a fetched page body:

{
  "type": "html",
  "parameters": {
    "operation": "extractHtmlContent",
    "sourceData": "json",
    "dataPropertyName": "response.body",
    "extractionValues": {
      "values": [
        {
          "key": "headline",
          "cssSelector": "h1.main-title",
          "returnValue": "text",
          "returnArray": false
        },
        {
          "key": "publishDate",
          "cssSelector": ".publish-date",
          "returnValue": "attribute",
          "attribute": "datetime",
          "returnArray": false
        },
        {
          "key": "tags",
          "cssSelector": ".tag",
          "returnValue": "text",
          "returnArray": true
        },
        {
          "key": "content",
          "cssSelector": ".article-body",
          "returnValue": "html",
          "skipSelectors": ".advertisement, .related-links",
          "returnArray": false
        }
      ]
    },
    "options": {
      "trimValues": true,
      "cleanUpText": true
    }
  }
}

Build a fully styled table from every input item:

{
  "type": "html",
  "parameters": {
    "operation": "convertToHtmlTable",
    "tableOptions": {
      "capitalize": true,
      "customStyling": true,
      "caption": "Sales Report",
      "tableAttributes": "class=\"data-table\" id=\"sales\"",
      "headerAttributes": "class=\"table-header\"",
      "rowAttributes": "class=\"table-row\"",
      "cellAttributes": "class=\"table-cell\""
    },
    "maxConcurrency": 1
  }
}

Build a table with the built-in default styling:

{
  "type": "html",
  "parameters": {
    "operation": "convertToHtmlTable",
    "tableOptions": {
      "capitalize": false,
      "customStyling": false
    }
  }
}

Error Handling

Tips

This tool generates HTML from templates, extracts data from HTML using CSS selectors, and converts JSON items into an HTML table. It is ideal when you need to dynamically create HTML content, parse existing HTML for specific information, or present structured data in a tabular HTML format. The tool produces rendered HTML as JSON, extracted data as JSON, or an HTML table as JSON, with an option to output generated HTML as a binary .html file.

Common Patterns

• Dynamic email templates — render personalised HTML per item with {{ $json.firstName }}-style placeholders, then hand the result to an email node.
• Web scraping — chain HTTP Request into Extract HTML Content, pointing JSON Property at the response body and defining one extraction rule per field you want.
• Data reports — feed a query result into Convert to HTML Table with Capitalize Headers on for a presentable report.

Parameter Dependencies

• Generate HTML Template: Output as Binary, Binary Property and File Name work together for file output.
• Extract HTML Content: Source Data decides whether Input Binary Field or JSON Property is used; Extraction Values defines what to extract; Options refines whitespace handling.
• Convert to HTML Table: everything is optional and only affects styling.

Notes

• HTML Template takes platform expressions only — {{ $json.field }} and the like. Templating-language constructs such as loops or conditionals are not evaluated and will appear literally in the output.
• text extraction concatenates the text of every matched element unless Return Array is on. When a selector can match more than one element, turn Return Array on to keep the values separate.
• Skip Selectors removes matching child elements before text is read, which is the cleanest way to drop adverts and navigation from an article body.