Automate Lemlist Reply Routing with n8n & OpenAI

If you are running any kind of cold outreach or nurture campaigns, you know the drill. Replies start rolling in, and suddenly your inbox is full of:

• People asking to unsubscribe
• Genuinely interested leads
• Out-of-office messages
• Random replies that do not fit any neat box

Now imagine not having to manually read and sort all of that. This n8n workflow template connects Lemlist, OpenAI, HubSpot, and Slack so replies get auto-classified and routed to the right action. No more inbox triage marathons, no more missed hot leads.

Let us walk through what this template does, when you would want to use it, and exactly how each piece fits together.

---

What this n8n + Lemlist + OpenAI workflow actually does

At a high level, the workflow listens for a reply in Lemlist, sends the text to OpenAI for classification, then uses that result to decide what to do next. Depending on the category, it can:

• Instantly unsubscribe someone from your Lemlist campaign
• Mark a lead as interested, create a HubSpot deal, and ping your team on Slack
• Create a follow-up task in HubSpot for out-of-office replies
• Send anything else to Slack for manual review

So instead of you skimming every reply, n8n quietly does the sorting for you in the background.

---

Why bother automating Lemlist reply routing?

If you are already getting replies, you might be thinking, “I can just do this manually.” You can, but here is what automation gives you:

• Immediate unsubscribe handling so you stay compliant and respectful
• Faster response to interested leads by pushing them straight into your CRM and Slack
• Structured follow-up on out-of-office replies instead of forgetting to circle back
• Fewer mistakes since you are not relying on a human skimming subject lines at 6 pm

In short, this workflow keeps your outreach clean, compliant, and fast, while freeing you from repetitive inbox admin.

---

How the workflow is structured in n8n

Here is the full journey of a reply, from Lemlist to the right destination:

1. Lemlist detects a reply and triggers the n8n workflow.
2. The reply text goes to OpenAI to be classified into one of four buckets.
3. A Merge node combines the classification with the original Lemlist data.
4. A Switch node routes the item into one of four branches:
   • Unsubscribe
   • Interested
   • Out of Office
   • Other
5. Each branch runs its own set of actions in Lemlist, HubSpot, and Slack.

Let us go through each part so you know exactly what is happening and what can be customized.

---

Step-by-step n8n node breakdown

1) Lemlist – Lead Replied (Trigger)

Everything starts with the Lemlist trigger node. Configure it with the emailsReplied event so the workflow runs every time a lead replies to your campaign.

Key points when setting it up:

• Configure the webhook correctly in Lemlist so replies fire the trigger.
• Optionally enable isFirst if you only want the first reply from each lead.

This node sends useful data into the workflow, including:

• text – the reply body
• leadEmail – the lead’s email address
• campaignId – the campaign the reply belongs to
• Other metadata like team and campaign details

You will use these fields later in HubSpot, Slack, and Lemlist actions.

---

2) OpenAI – classify the reply

Next, the reply text is sent to OpenAI to figure out what kind of message it is. The goal is to map each email into one of these categories:

• interested
• Out of office
• unsubscribe
• other

To keep the model predictable, use a deterministic setup:

• temperature = 0
• topP = 1
• maxTokens = 6

Here is an example prompt used in the template:

The following is a list of emails and the categories they fall into:
Categories=["interested", "Out of office", "unsubscribe", "other"]

Interested is when the reply is positive.

{{$json["text"].replaceAll(/^\s+|\s+$/g, '').replace(/(\r\n|\n|\r)/gm, "")}}
Category:

The node responds with a short label like unsubscribe or interested. That tiny string is what drives the routing logic later on.

---

3) Merge – combine OpenAI result with the original Lemlist data

Now you have two streams of information in n8n:

• The original Lemlist reply payload
• The OpenAI classification result

The Merge node brings them together into a single item.

Configure the Merge node to:

• Use Combine mode
• Use mergeByPosition

This way, the output JSON has both the reply text and the classification in one place, which makes it easy for the Switch node to do its job.

---

4) Switch – route based on the reply category

The Switch node looks at the classification text and decides which branch to follow. You can set it up to do string matches on the category value.

An example configuration might look like this:

value1 = {{$json["text"].trim()}},
rules: ["Unsubscribe" -> output 1, "Interested" -> output 2, "Out of Office" -> output 3],
fallback -> output 4

One important detail: OpenAI may return lowercase values like unsubscribe instead of Unsubscribe. To avoid routing issues, you can:

• Normalize the text using toLowerCase(), or
• Add multiple rule variants, such as "unsubscribe" and "Unsubscribe"

From here, each branch handles a specific type of reply.

---

Branch-by-branch actions

Unsubscribe branch

When the classification is “unsubscribe”, you want to act quickly and cleanly.

In this branch, the workflow calls a Lemlist node configured to unsubscribe the lead from the campaign. A typical configuration is:

email = {{$json["leadEmail"]}}

This instantly removes the lead from your sequences and helps you stay on top of compliance and user trust.

---

Interested branch

This is the fun one. When someone replies with interest, you want them in your CRM and in front of your team as fast as possible.

The “Interested” branch performs two main actions:

1. Mark the lead as interested in Lemlist
2. Create or update a contact and deal in HubSpot, then send a Slack notification

1. Mark as interested in Lemlist

Use an HTTP Request node to call the Lemlist API and mark the lead as interested:

POST https://api.lemlist.com/api/campaigns/YOUR_CAMPAIGN_ID/leads/{{$json["leadEmail"]}}/interested

Replace YOUR_CAMPAIGN_ID with your actual campaign ID.

2. Create or update in HubSpot and notify Slack

Next, the workflow:

• Uses a HubSpot node to upsert or fetch a contact by email
• Creates a deal for that contact in your chosen pipeline
• Sends a Slack message with a direct link to the HubSpot deal

The HubSpot nodes in this template use OAuth2. When upserting the contact, you can pass first and last name via additionalFields. After the deal is created, the Slack node shares a link like:

https://app-eu1.hubspot.com/contacts/PORTAL_ID/deal/{{$json["dealId"]}}

Make sure to adjust your HubSpot region and PORTAL_ID to match your account.

---

Out of Office branch

Out-of-office replies are not a “no”, they are a “not now”. This branch makes sure you do not forget to follow up.

Here is what happens:

• The workflow gets or upserts the contact in HubSpot, so the person exists as a contact.
• It then creates an engagement of type task in HubSpot.

You can set a task subject such as:

OOO - Follow up with {{firstname}} {{lastname}}

Schedule the task for the appropriate follow-up date, based on how you want to handle out-of-office responses.

---

Other branch

Not every reply will fit nicely into “interested”, “unsubscribe”, or “out of office”. For everything else, the workflow routes the message into a Slack notification for manual review.

Typically this includes:

• The reply text itself
• Relevant Lemlist metadata
• A link back to the Lemlist campaign report

That way a human can scan the message and decide what to do, without you losing track of it.

---

Useful n8n expressions and snippets

A few expressions make this workflow more robust and cleaner to maintain.

Trim reply text to avoid whitespace issues

Leading or trailing spaces can cause Switch conditions or prompts to behave oddly. Use:

{{$json["text"].trim()}}

You can use this in the Switch node or in the OpenAI prompt.

Upsert a HubSpot contact with name fields

When working with HubSpot, you often want to store the lead’s name along with their email. Here is a typical expression setup:

email = {{$json["leadEmail"]}}
additionalFields.lastName = {{$json["leadLastName"]}}
additionalFields.firstName = {{$json["leadFirstName"]}}

This ensures your CRM stays clean and properly populated.

---

Testing and debugging the workflow

Before you trust this with your live outreach, it is worth running a few tests. Here is a simple approach:

• Use Execute Workflow or Active Webhook mode in n8n and send test replies from Lemlist.
• Temporarily log OpenAI outputs into a Slack or Email node so you can see exactly what category is returned.
• Start with cautious routing, for example send “interested” replies to a QA Slack channel first, and only later move to full automation.
• Normalize OpenAI output by trimming and using toLowerCase(), or define multiple Switch rules for common variations.

A bit of testing up front saves you from misrouted leads later.

---

Security, compliance, and reliability best practices

Because this workflow touches emails, PII, and external APIs, it is worth tightening up a few things.

• Use n8n credentials for all API keys instead of hardcoding them.
• Limit PII exposure by only sending the fields you truly need to external services, and follow GDPR or other privacy regulations.
• Implement error handling using n8n’s error workflow or retry logic to catch failed API calls and alert admins.
• Respect rate limits for OpenAI, Lemlist, and HubSpot. Add delays or concurrency limits if you are processing high volumes.

---

Ideas for advanced enhancements

Once the basic routing is working, you can gradually make the workflow smarter. For example, you could:

• Use embeddings or a small classifier model for more detailed categories like pricing questions or feature requests.
• Add sentiment scoring to highlight especially warm or urgent leads.
• Store every classified reply in a database such as Airtable or Postgres for reporting, trend analysis, and prompt improvements.
• Introduce a simple keyword-based allowlist or denylist for unsubscribe detection to reduce OpenAI calls and cut costs.

Think of the template as a strong starting point that you can layer more intelligence onto over time.

---

Troubleshooting common issues

Running into odd behavior? Here are a few quick checks:

• Inconsistent classification: Lower the temperature (keep it at 0) and add more explicit examples in your OpenAI prompt.
• Switch node not routing correctly: Inspect the Merge node output and confirm you are reading the correct property name. Also check for whitespace and casing issues.
• HubSpot deal creation errors: Double-check the deal stage ID and ensure your authenticated HubSpot account has the right scopes and permissions.

---

Wrap-up: what you get from this template

With this n8n + Lemlist + OpenAI workflow in place, you get:

• Automated triage of outreach replies
• Instant unsubscribe handling
• Faster routing of interested leads into HubSpot and Slack
• Structured follow-up for out-of-office messages
• A simple path for human review of edge cases

You can import the template into n8n, plug in your Lemlist, OpenAI, HubSpot, and Slack credentials, and be up and running quickly. From there, adjust the categories, prompts, and routing rules to match your tone and sales process.

Try the template now – import the workflow, connect your tools, and run it on a handful of test replies. If you want to adapt it for different HubSpot stages, more nuanced categories, or extra scoring logic, you can tweak the nodes or reach out for help.

Call-to-action: Ready to automate your reply handling and respond to leads faster? Import the template, run a 2-week experiment, and see the impact on your follow-up speed. If you get stuck or want a custom setup, reply to this post or contact us for a personalized walkthrough.

Build a Typeform Feedback Workflow in n8n

Collecting course feedback is critical for continuous improvement, but copying Typeform responses into Google Sheets by hand is slow and error prone. This guide explains, in a technical and implementation-focused way, how to build an n8n workflow that listens to Typeform submissions, normalizes the payload, evaluates a numeric rating, and appends positive and negative feedback to separate Google Sheets tabs automatically.

Workflow overview

This n8n workflow automates the full feedback pipeline from Typeform to Google Sheets. It:

• Subscribes to a specific Typeform form using a Typeform Trigger node (webhook-based).
• Normalizes the raw JSON into concise, reusable fields with a Set node.
• Routes each response into a positive or negative branch using an IF node based on a numeric rating.
• Appends positive feedback to one Google Sheets tab and negative feedback to another using two dedicated Google Sheets nodes.

The reference workflow consists of exactly five nodes:

• Typeform Trigger – Receives new submissions as JSON via webhook.
• Set – Extracts and renames relevant fields such as rating and opinion text.
• IF – Evaluates the rating against a threshold (for example, greater than or equal to 3).
• Google Sheets (positive) – Appends rows for responses classified as positive.
• Google Sheets (negative) – Appends rows for responses classified as negative.

This structure is intentionally simple and is a good starting point for more advanced n8n automation around feedback, sentiment analysis, and reporting.

Architecture and data flow

The automation follows a linear flow with a single branching decision:

1. Incoming webhook
   The Typeform Trigger node exposes a webhook URL. When a participant submits the form, Typeform sends a structured JSON payload to this URL. n8n starts a new execution for each submission.
2. Field normalization
   The Set node reads values from the incoming JSON using question labels as keys, then writes them to shorter, canonical field names. All downstream logic uses these normalized keys.
3. Conditional routing
   The IF node evaluates the normalized numeric rating field. If the value meets or exceeds a configured threshold, the execution flows through the “true” output. Otherwise, it follows the “false” output.
4. Persistence in Google Sheets
   Two separate Google Sheets nodes receive the routed items. One appends to a “positive” sheet or tab, the other to a “negative” sheet or tab. Both map fields such as timestamp, rating, and free-text opinion into columns.

No additional transformation or external services are required for the core template. All logic is contained within these five nodes.

Node-by-node configuration

1. Typeform Trigger node

The Typeform Trigger node is responsible for connecting n8n to the Typeform form you want to monitor. It operates via a webhook endpoint that Typeform calls on each new submission.

Key parameters

• Form ID
  Set this to the identifier of your Typeform, for example yxcvbnm. You can find this ID in the Typeform URL or in the Typeform dashboard.
• Webhook URL
  Once you activate the node or the workflow, n8n generates a webhook URL. You can:
  • Register this URL manually in your Typeform form’s webhook settings, or
  • Use the built-in integration from within the Typeform Trigger node if available in your n8n version.

  The webhook must be active and reachable for submissions to trigger the workflow.

• Credentials
  Configure and select your Typeform API credentials in n8n. These credentials allow n8n to validate the webhook and, if needed, fetch related form data. Ensure:
  • The access token is valid and has the required scopes for webhooks and responses.
  • The credentials are selected in the Typeform Trigger node.

Runtime behavior

On each submission, Typeform sends a JSON payload to n8n. This payload typically includes:

• Metadata such as submission ID and timestamps.
• Answers keyed by question identifiers or labels.

The node passes the raw JSON to the next node as $json. All subsequent nodes read from this structure.

Edge cases

• Webhook not firing – Confirm that the webhook URL is correctly registered in Typeform and that the n8n workflow is active. If you change the workflow environment (for example, URL or tunnel), you need to re-register the webhook.
• Changed form structure – If you modify questions or labels in Typeform, the JSON shape may change. You will need to update expressions in downstream nodes, especially the Set node.

2. Set node – normalize answers

The Set node standardizes the incoming payload into concise keys that are easier to work with in conditions and expressions. Instead of referencing long question texts repeatedly, you map them once in this node.

Example field mappings

In the template, the Set node defines at least two fields:

• usefulness → {{$json["How useful was the course?"]}} This is expected to be a numeric rating (for example, on a 1-5 scale).
• opinion → {{$json["Your opinion on the course:"]}} This is a free-text feedback field.

You can add more fields in the Set node if your Typeform includes additional questions that you want to store in Google Sheets or use for routing.

Configuration notes

• Keep Key-Value Mode enabled so that each new property is defined explicitly.
• Data types – Ensure that the rating field is stored as a number. If Typeform sends it as a string, n8n usually handles numeric comparison correctly, but you should verify the value in the execution preview.
• Field naming – Use short, stable keys such as usefulness or rating instead of full question labels to make expressions and conditions easier to maintain.

Impact of question label changes

The expressions in this node rely on exact question labels like "How useful was the course?". If you update the question text in Typeform, the path $json["How useful was the course?"] may no longer resolve. In that case:

• Trigger a new test submission.
• Inspect the raw JSON in n8n’s execution log.
• Update the expressions in the Set node accordingly.

3. IF node – route by rating

The IF node splits the workflow into two branches based on the rating captured in the Set node. This is the core decision point that determines whether a response is handled as positive or negative feedback.

Condition configuration

Use the following example condition:

Number:  value1  = {{$json["usefulness"]}}  operation = largerEqual  value2  = 3

This configuration means:

• The node reads the numeric value from $json["usefulness"].
• It compares this value using the largerEqual operation.
• If the rating is greater than or equal to 3, the condition evaluates to true.
• Otherwise, it evaluates to false.

Branch semantics

In n8n, the IF node has two outputs:

• Output 1 (index 0) – The “true” branch. All items that satisfy the condition are passed here.
• Output 2 (index 1) – The “false” branch. All items that do not satisfy the condition are passed here.

Connect these outputs as follows:

• True branch (index 0) → Google Sheets node for positive feedback.
• False branch (index 1) → Google Sheets node for negative feedback.

Potential pitfalls

• Incorrect connections – If you accidentally swap the outputs, positive ratings may be stored as negative and vice versa. Double check the node connections visually and verify with test submissions.
• Null or missing values – If the usefulness field is missing or not numeric, the condition may behave unexpectedly. Use the execution preview to confirm that the Set node always produces a valid numeric value.

4. Google Sheets nodes – append rows

The workflow uses two separate Google Sheets nodes to persist feedback. One handles positive responses, the other handles negative responses. Both are configured similarly, with only the target range or sheet differing.

Common configuration parameters

• Operation
  Set to append. This adds each new feedback record as a new row at the end of the specified range or sheet.
• Range
  Use the format <sheet_tab_name>!<column_range>. For example:
  • Positive feedback: positive_feedback!A:C
  • Negative feedback: negative_feedback!A:C

  If you omit the range, Google Sheets appends to the default sheet, but using explicit ranges makes the behavior more predictable.

• Spreadsheet ID
  Set the Sheet ID to the ID from your Google Sheets URL. It is the long string between /d/ and /edit in the URL. Ensure the ID matches the spreadsheet that contains your positive and negative tabs.
• Authentication
  Select your oAuth2 credentials configured in n8n. The associated Google account must have write access to the target spreadsheet.

Field mapping

Within each Google Sheets node, map the fields you want to store. Typical mappings include:

• Timestamp – For example, {{ new Date().toISOString() }} for an ISO 8601 timestamp.
• Rating – {{$json["usefulness"]}}
• Opinion text – {{$json["opinion"]}}

If your sheet includes a header row, configure the keyRow parameter so that n8n aligns values with the correct columns. The header names should match the keys you map in the node.

Positive vs negative nodes

The two Google Sheets nodes are logically identical except for:

• The tab name and range, for example:
  • positive_feedback!A:C
  • negative_feedback!A:C
• The branch they are connected to:
  • Positive node receives items from the IF node’s true output.
  • Negative node receives items from the IF node’s false output.

Configuration checklist

Before running the workflow in production, verify the following:

• Typeform Trigger:
  • Correct Form ID set.
  • Webhook URL registered and active in Typeform.
  • Typeform credentials valid and selected.
• Set node:
  • Expressions reference the correct question labels.
  • Rating field resolves to a numeric value.
• IF node:
  • Threshold value set as intended (for example, 3).
  • True and false outputs connected to the correct Google Sheets nodes.
• Google Sheets nodes:
  • Spreadsheet ID matches your target document.
  • Ranges use correct tab names and column ranges.
  • OAuth2 credentials have write access.
  • Header row configuration (keyRow) matches your sheet layout.

Expressions and common n8n patterns

This workflow relies heavily on n8n expressions to access JSON fields and generate dynamic values. Some useful patterns:

• Access a specific question’s answer directly from the Typeform payload
  {{$json["Your opinion on the course:"]}}
• Use normalized fields from the Set node
  {{$json["usefulness"]}} and {{$json["opinion"]}}
• Generate a timestamp
  {{ new Date().toISOString() }}

When building more complex automations, you can reuse the same patterns to enrich data, build conditional logic, or integrate with other APIs.

Testing and validation

Validate the workflow end to end before relying on it in production. A typical test process:

1. Submit test responses in Typeform
   Use different rating values, including both below and above the threshold (for example, 2 and 4), to exercise both branches of the IF node.
2. Inspect n8n execution logs
   Open the workflow executions in n8n and:
   • Check the payload received by the Typeform Trigger node.
   • Verify that the Set node outputs the expected usefulness and opinion fields.
   • Confirm that the IF node routes each item to the correct branch.
3. Verify Google Sheets output
   Ensure that:
   • Positive ratings appear in the positive feedback tab.
   • Lower ratings appear in the negative feedback tab.
   • Columns are aligned with headers and no values are shifted.

If data does not appear as expected, review the configuration checklist and adjust node settings accordingly.

Troubleshooting and operational tips

• Wrong or missing field names
  If the Set node expressions return null or undefined values:
  • Submit a fresh response.
  • Open the execution and inspect the raw JSON.
  • Update expressions like $json["How useful was the course?"] to match the current payload.
• Authentication errors with Google Sheets
  HTTP 401 or 403 errors typically indicate:
  • Expired or revoked OAuth2 credentials.
  • Insufficient permissions for the Google account.

  Reconnect the OAuth2 credentials in n8n and verify that the account has edit access to the spreadsheet.

• Range and tab issues
  If rows are not appearing where expected:
  • Confirm that tab names in positive_feedback!A:C and negative_feedback!A:C exactly match the sheet tabs
    

Automate Typeform Feedback to Google Sheets with n8n

Collecting course feedback is only useful if you can quickly turn it into structured, actionable data. This guide explains, in a technical and reference-style format, how to implement a complete Typeform → n8n → Google Sheets workflow. The workflow listens for new Typeform submissions, normalizes the payload, evaluates a numeric rating, and routes positive and negative feedback into separate Google Sheets.

The walkthrough is based on the sample template JSON referenced in the original article and focuses on node configuration, data flow, and practical implementation details. All steps and parameters are preserved, but organized in a more systematic, documentation-style layout.

---

1. Workflow Overview

This automation uses an n8n workflow template composed of five core nodes:

• Typeform Trigger – Receives new form submissions via webhook.
• Set – Extracts and normalizes key fields from the Typeform payload.
• IF – Evaluates a numeric rating to determine feedback polarity.
• Google Sheets (positive_feedback) – Appends positive responses to a specific sheet.
• Google Sheets (negative_feedback) – Appends negative responses to a separate sheet.

The result is a fully automated pipeline that:

• Captures all Typeform responses in real time.
• Segments feedback based on a rating threshold.
• Stores positive and negative feedback in separate, structured Google Sheets.
• Provides a base for further automations, such as alerts or follow-up actions.

---

2. Architecture & Data Flow

2.1 Logical Flow

1. Typeform submits a response to the configured form.
2. Typeform Trigger node in n8n receives the webhook payload.
3. Set node reads the incoming JSON, extracts the rating and free-text opinion, and outputs a minimal, normalized object.
4. IF node evaluates the numeric rating against a predefined threshold (e.g. rating ≥ 3 is considered positive).
5. If the condition is true, the item flows to the positive Google Sheets node, which appends a row to the positive_feedback sheet.
6. If the condition is false, the item flows to the negative Google Sheets node, which appends a row to the negative_feedback sheet.

2.2 Core Use Cases

• Automated segmentation of course feedback by sentiment or satisfaction score.
• Continuous, timestamped logging of feedback in Sheets for reporting and analysis.
• Triggering downstream workflows for negative feedback (support alerts, tickets, follow-up emails).

---

3. Node-by-Node Breakdown

3.1 Typeform Trigger Node

Role: Ingest new Typeform submissions into n8n via webhook.

3.1.1 Essential Configuration

• webhookId: 1234567890 (template placeholder)
• formId: yxcvbnm (template placeholder)
• Credentials: Typeform credentials configured in n8n (API key or Typeform integration)

In n8n, the Typeform Trigger node typically registers a webhook with Typeform. When a respondent submits the form, Typeform sends an HTTP POST to n8n containing the response payload.

3.1.2 Connectivity & Webhook Activation

• Ensure the webhook is enabled in your Typeform account for the specified formId.
• If n8n is self-hosted, expose your instance via a public URL or tunneling solution so Typeform can reach the webhook endpoint.
• Use a test submission in Typeform to confirm that:
  • The webhook is firing correctly.
  • n8n receives the payload without errors.
  • The payload structure matches what the downstream nodes expect.

3.1.3 Edge Cases

• If no data appears in n8n, check the webhook status in Typeform and verify that the n8n URL is accessible from the internet.
• For form changes (new questions, label changes), re-check the payload structure before adjusting mappings in the Set node.

---

3.2 Set Node (Capture & Normalize Typeform Data)

Role: Transform the raw Typeform JSON into a compact, normalized object that contains only the fields required for routing and storage.

3.2.1 Template Configuration

The template uses a Set node configured with explicit mappings:

{  "values": {  "number": [  {  "name": "usefulness",  "value": "={{$json[\"How useful was the course?\"]}}"  }  ],  "string": [  {  "name": "opinion",  "value": "={{$json[\"Your opinion on the course:\"]}}"  }  ]  },  "keepOnlySet": true
}

This configuration:

• Defines a numeric field usefulness mapped from the question labeled "How useful was the course?".
• Defines a string field opinion mapped from the question labeled "Your opinion on the course:".
• Enables keepOnlySet to remove all other properties from the incoming JSON, leaving only the normalized fields.

3.2.2 Label vs Key-Based Mapping

• Using the text labels (as in the example) is convenient but sensitive to label changes in Typeform.
• For more stable workflows, you can map using the underlying response keys from the raw payload instead of the human-readable labels.

3.2.3 Practical Notes

• Ensure the Typeform question labels in the expressions match exactly, including punctuation and capitalization.
• If the rating is delivered as a string, the IF node will still work if n8n can coerce it to a number, but for safety you can cast explicitly in the expression if needed.
• keepOnlySet: true is recommended for clarity and performance, especially when you only need a small subset of the payload.

---

3.3 IF Node (Feedback Segmentation)

Role: Route feedback to different branches based on the numeric rating.

3.3.1 Template Condition

The IF node checks the usefulness value created by the Set node:

{  "conditions": {  "number": [  {  "value1": "={{$json[\"usefulness\"]}}",  "operation": "largerEqual",  "value2": 3  }  ]  }
}

Behavior:

• If usefulness ≥ 3, the item is routed to the true branch (index 0), considered positive feedback.
• If usefulness < 3 or not provided (and cannot be parsed), the item goes to the false branch (index 1), treated as negative or non-positive feedback.

3.3.2 Threshold Selection

• The example uses 3 as the cutoff for a typical 1-5 scale.
• For stricter segmentation, many teams prefer ≥ 4 as the threshold for positive feedback.
• Adjust the value2 parameter to match your rating policy.

3.3.3 Edge Cases & Data Types

• If the rating is missing or not a valid number, the condition may fail or behave unexpectedly. Inspect the raw payload if routing does not match your expectations.
• To avoid type issues, you can ensure the value is numeric in the Set node (for example, by using an expression that parses the value) before it reaches the IF node.

---

3.4 Google Sheets Nodes (Append Positive & Negative Feedback)

Role: Persist feedback into two separate Google Sheets ranges for later analysis and reporting.

3.4.1 Positive Feedback Node

Template configuration for the positive branch:

• Operation: append
• Range: positive_feedback!A:C
• sheetId: asdfghjklöä (placeholder, replace with your actual sheet ID)
• Authentication: oAuth2

This node appends a new row to the positive_feedback sheet in the specified Google Spreadsheet for each item that passes the IF condition.

3.4.2 Negative Feedback Node

Template configuration for the negative branch:

• Operation: append
• Range: negative_feedback!A:C
• sheetId: qwertzuiop (placeholder, replace with your actual sheet ID)
• Authentication: Typically the same OAuth2 credential as the positive node

This node appends rows to the negative_feedback sheet whenever the rating does not meet the positive threshold.

3.4.3 Sheet Structure & Headers

• Create descriptive header rows in both sheets (e.g. Timestamp, Usefulness, Opinion, Submission ID).
• Enable keyRow in the Google Sheets node if you want to reference columns by name in n8n.
• Ensure that the range (e.g. A:C) covers all columns you intend to populate.

3.4.4 Credentials & Access

• Use a dedicated OAuth2 credential or service account to limit access and make the integration easier to maintain.
• Verify that the configured account has write access to the target spreadsheet.

3.4.5 Failure Modes

• Incorrect sheetId or sheet name will cause append operations to fail.
• If the OAuth token is expired or revoked, n8n will return authentication errors until reauthorized.
• Mismatched ranges (e.g. fewer columns than provided data) can lead to unexpected alignments in the sheet.

---

4. Configuration Notes & Best Practices

4.1 Mapping Fields From Typeform

• Always check the raw webhook payload from Typeform when you first configure the workflow.
• Use stable identifiers (question IDs or keys) where possible to reduce breakage when labels change.
• Document which Typeform questions map to which n8n fields, especially for multi-question forms.

4.2 Avoiding Duplicates and Ensuring Auditability

• Store a unique submission identifier (if available in the payload) in your sheets.
• Include timestamps so you can track when each response was received and processed.
• These fields make it easier to detect duplicates and perform historical analysis.

4.3 Security & Privacy Considerations

• Only capture and persist fields that are strictly necessary for your analysis or follow-up.
• Avoid storing sensitive personal data in Google Sheets unless you have a clear policy and safeguards.
• Use OAuth2 with the minimal required scopes for Google Sheets access.
• Secure your n8n instance with HTTPS, strong credentials, and IP allowlists where possible.

---

5. Enhancements & Real-World Improvements

5.1 Add Timestamps and Responder Metadata

To provide context for each row in Google Sheets, you can extend the Set node to include metadata from the Typeform payload, such as submission time.

Example expression for a timestamp field:

timestamp: ={{$json["submitted_at"] || new Date().toISOString()}}

This expression attempts to use the submitted_at field from Typeform and falls back to the current time if it is not present.

5.2 Sanitize and Validate Input

Before writing to Google Sheets, you can introduce additional nodes to clean and validate data:

• Function node to:
  • Trim whitespace from text responses.
  • Remove or escape HTML if present.
  • Limit text length for very long comments.
• IF nodes to:
  • Skip rows that lack required fields.
  • Handle invalid or out-of-range ratings.

5.3 Automatic Follow-Up Actions for Negative Feedback

For responses routed to the negative branch (rating below the threshold), you can extend the workflow with additional nodes, such as:

• Slack node to send an immediate alert to a support or course team channel.
• Helpdesk integration node (e.g. Zendesk, Freshdesk) to create a support ticket.
• Email node to send a personalized follow-up or apology email, optionally including a link to a more detailed feedback form.

These actions can be chained after the negative Google Sheets node or in parallel, depending on your process.

5.4 Error Handling & Retries

Google Sheets API calls may occasionally fail due to rate limits or transient network issues. To handle this robustly:

• Use n8n’s built-in retry options where available on the Sheets nodes.
• Alternatively, implement a retry pattern by:
  • Wrapping the Sheets node in a sub-workflow or using additional nodes to:
  • On failure, wait for X seconds and retry up to N times.
• For permanent failures, log the problematic payloads to:
  • A dedicated “errors” sheet, or
  • An external error tracking or logging service.

---

6. Troubleshooting Reference

6.1 No Incoming Data in n8n

• Verify that the Typeform webhook is enabled and associated with the correct formId.
• Check that the public URL of your n8n instance is reachable from the internet.
• Send a test submission from Typeform and inspect the execution logs in n8n.

6.2 Missing or Empty Field Values

• Compare the question labels used in the Set node with the actual labels in Typeform.
• Inspect the raw JSON payload from the Typeform Trigger node to identify the exact keys.
• Update the Set node expressions if labels or structure have changed.

6.3 Google Sheets Append Errors

• Confirm that the sheetId matches the target spreadsheet.
• Ensure that the specified range (e.g. positive_feedback!A:C) exists and that the sheet name is correct.
• Check that
  

LinkedIn AI Agent: Automate Content with n8n

Automating LinkedIn content creation and publishing is now practical and accessible. With a carefully designed n8n workflow that connects tools like Airtable, Apify, OpenAI, Telegram, and the LinkedIn API, you can:

• Scrape posts from competitors or favorite creators
• Extract and repurpose high-value content automatically
• Store drafts for human review in Airtable
• Publish approved posts to LinkedIn on a schedule

All of this happens while you keep full editorial control over what actually goes live.

---

What you will learn in this guide

This article walks you through the LinkedIn AI Agent workflow template in n8n step by step. By the end, you will understand how to:

• Set up an automated content pipeline using n8n
• Scrape LinkedIn posts with Apify and avoid duplicates
• Extract and classify content (text, image, video, document)
• Repurpose content with OpenAI into multiple LinkedIn-ready formats
• Manage an editorial queue in Airtable and keep humans in the loop
• Publish posts automatically through the LinkedIn API
• Apply best practices for security, quality, and scaling

---

Concept overview: How the LinkedIn AI Agent works

Before we dive into the step-by-step build, it helps to understand the big picture. The workflow is built around three core ideas:

1. A consistent content pipeline

Brands and creators grow on LinkedIn when they publish consistent, high-quality content. The AI Agent supports this by automating the pipeline from discovery to publishing:

1. Discover relevant posts from selected creators or competitors
2. Extract insights and text from different content types
3. Repurpose the content into several LinkedIn-friendly formats
4. Store everything as drafts in Airtable for review
5. Publish approved content at scheduled times

The outcome is higher content velocity, better reuse of ideas, and a more predictable posting schedule.

2. Key tools and integrations

The workflow relies on a few main components, each with a specific role:

• n8n – The automation engine that orchestrates the whole process using nodes, triggers, and conditional logic.
• Apify – Scrapes LinkedIn posts from chosen profiles or creators. This is often used for competitor or inspiration scraping.
• Airtable – Acts as your content database and editorial dashboard. It stores creators, scraped posts, repurposed drafts, statuses, and metadata.
• OpenAI (GPT-4o / GPT-4o Vision) – Repurposes content, rewrites posts, transcribes audio or video, and analyzes images.
• Telegram (optional) – Provides a human-in-the-loop channel where you can send ideas or voice notes into the workflow.
• LinkedIn API – Publishes content (text-only or with images) directly to LinkedIn from n8n.

3. Three main workflow sections

The template is easiest to understand if you think of it as three connected but distinct sections:

1. Competitor’s Scraping – Finds and fetches new LinkedIn posts.
2. Content Extraction & Repurposing – Extracts text and transforms it into new LinkedIn content.
3. Airtable, Review & Auto Publishing – Manages the editorial queue and publishes approved posts.

---

Step-by-step: Building and understanding the workflow in n8n

Step 1: Configure the content discovery (Competitor’s Scraping)

This first section runs on a schedule and keeps your content pipeline filled with fresh material.

1.1 Schedule Trigger

In n8n, start with a Schedule Trigger node:

• Set it to run at the frequency you prefer, such as daily or weekly.
• This ensures the workflow automatically checks for new posts without manual input.

1.2 Load target creators from Airtable

Next, add a node to Get Creators from Airtable:

• Connect to your Airtable base where you store a list of creators or competitors.
• Each record typically includes fields like LinkedIn profile URL, creator name, and any tags or notes.
• The workflow loops through this list and treats each creator as a source to scrape.

1.3 Scrape LinkedIn posts with Apify

For each creator, use an Apify node configured to Scrape LinkedIn Posts:

• Call an Apify actor that is set up to fetch recent posts for the given profile.
• Make sure to pass in the correct parameters, such as profile URL and the number of posts to fetch.
• Apify returns structured data for each post, including IDs, text, media links, and timestamps.

1.4 Filter out existing posts to avoid duplicates

Once Apify returns the posts, add a Filter Out Existing Posts step:

• Compare each scraped post’s unique ID against the records stored in Airtable.
• If the post ID already exists, skip it to avoid processing the same content twice.
• Only new posts move forward in the workflow.

This deduplication step keeps your system efficient and prevents repeated repurposing of the same content.

---

Step 2: Extract and repurpose content with OpenAI

After the workflow has identified new posts, it needs to understand what type of content each one is and extract usable text.

2.1 Detect the content type

Add a Switch Content Type node in n8n:

• This node checks what kind of content was scraped: text, image, video, or document.
• Each type follows a slightly different extraction path, but all of them end up as text for OpenAI.

2.2 Handle each content type

• Text
  If the original post is text-only:
  • The text can be captured directly from the scraped data.
  • No extra processing is required before sending it to OpenAI.
• Document
  If the post contains a document, such as a PDF:
  • Download the document file using its URL.
  • Run it through a PDF extractor or similar tool to capture the internal text.
  • Clean up the extracted text if necessary before repurposing.
• Image
  If the post includes an image:
  • Send the image to OpenAI Vision (GPT-4o with vision capabilities).
  • Ask it to extract any embedded text and describe the context of the image.
  • Use this description as the basis for the repurposed content.
• Video
  If the post is a video:
  • Download the video file from the scraped URL.
  • Reformat it if needed so it is compatible with your transcription tool.
  • Transcribe the audio to capture the spoken script.
  • The resulting transcript becomes the text input for OpenAI.

2.3 Merge extracted text into a standard record

Regardless of the original source, the final goal of this section is to produce a standardized text record. In n8n you can:

• Combine fields like title, description, transcript, and image description into one unified text block.
• Attach metadata such as creator name, original URL, and content type to this record.

2.4 Repurpose with OpenAI into three content variants

Now connect an OpenAI node configured to repurpose the text into multiple LinkedIn-ready formats. A common setup is to ask for three variants:

1. Text-only LinkedIn post – A clear, engaging post suitable to publish as plain text.
2. Text + image (tweet-style visual) – A version that includes copy designed to be placed on an eye-catching image, similar to a tweet-style graphic.
3. Text + infographic instructions – Detailed guidance for a designer, including layout ideas, sections, and chart suggestions for an infographic.

The OpenAI node typically returns a structured JSON, for example:

{  "relevant": true,  "text": "...",  "infographic": "...",  "tweet": "..."
}

The relevant field is important:

• If the source content is marketing-related or valuable, the node marks "relevant": true and the workflow continues.
• If the content is not suitable for your LinkedIn strategy, it can mark it as irrelevant and the workflow skips further processing.

---

Step 3: Manage drafts in Airtable and publish via LinkedIn

Once OpenAI has generated the repurposed content, the workflow moves into the editorial and publishing phase.

3.1 Store repurposed outputs in Airtable

Create an Airtable base that acts as your editorial queue. For each repurposed item, store fields such as:

• Final text for the LinkedIn post
• Image URLs or design instructions (for visual posts)
• Infographic brief for designers
• Original source URL and creator
• Content type (text-only, image, infographic)
• Status (for example: review, ready, posted)

This structure lets your team see what has been generated, what needs review, and what is scheduled to go live.

3.2 Keep humans in the loop for editorial control

One of the strengths of this workflow is that it does not remove human judgment. Instead, it supports it:

• Editorial control – Team members can open Airtable, review the generated posts, make edits, and change the status from review to ready when they approve.
• Optional Telegram integration – If you use Telegram, you can also send ideas or voice notes that flow into the same Airtable queue, giving you a central place for all content.

3.3 Schedule automatic publishing from Airtable

To publish approved posts, add a second Schedule Trigger in n8n that handles Publishing:

• This schedule might run multiple times per day, depending on your posting strategy.
• On each run, the workflow queries Airtable for records where status = ready.
• Those posts are then passed to the LinkedIn publishing logic.

3.4 Publish to LinkedIn with or without media

Use the LinkedIn API node in n8n to publish:

• Publish paths – If the Airtable record includes an image URL or generated media, the workflow creates a LinkedIn post with media attached.
• If there is no associated image, the workflow publishes a text-only post.

3.5 Update Airtable after publishing

Once the LinkedIn post is successfully published:

• The workflow updates the corresponding Airtable record to set status = posted.
• This prevents the same content from being published again in future runs.

---

Practical configuration tips for a stable workflow

Security and credentials

Because this workflow touches several APIs, secure configuration is essential:

• Store all API keys and OAuth credentials in n8n’s credentials manager, not in plain text inside nodes.
• Rotate keys on a regular schedule to reduce security risk.
• Use scoped tokens where possible, such as:
  • Airtable Personal Access Tokens with only the required bases and permissions.
  • LinkedIn OAuth clients with limited scopes that only allow necessary publishing actions.

Rate limits and retries

External services like Apify, OpenAI, and LinkedIn enforce rate limits:

• Use exponential backoff and retry logic in n8n’s HTTP Request nodes when calling APIs directly.
• Where supported, enable credentials throttling in n8n so requests are automatically paced.
• Spread your scraping and publishing tasks throughout the day instead of running everything at once.

Error handling for robustness

Errors will happen, especially with file downloads, transcriptions, and uploads. Plan for them:

• Use onError handlers on critical nodes to prevent the entire workflow from failing.
• Log failed items to a dedicated Airtable table or a Slack channel for manual review.
• Include meaningful error messages and metadata so you can quickly see what went wrong.

Data quality and deduplication

Good data hygiene makes your analytics and editorial work easier:

• Normalize fields such as dates, author names, and URLs before writing to Airtable.
• In addition to checking post IDs, add checks for near-duplicate content, for example:
  • Similar titles or text segments
  • Very small variations of the same idea
• This helps avoid reposting the same concept with only minor edits.

---

Best practices for repurposed LinkedIn content

Automation is powerful, but the content still needs to perform well on LinkedIn. Keep these guidelines in mind:

• Prioritize value – Focus on posts that offer clear lessons, frameworks, or case studies instead of vague inspiration.
• Use strong hooks – Make the first 1 to 2 sentences attention-grabbing to improve engagement and dwell time.
• Keep it scannable – Use short paragraphs, numbered lists, and bullet points to make posts easy to read.
• Add a call to action – Encourage readers to comment, repost, or follow to boost interaction.
• Experiment with formats – Test text-only posts versus image-driven posts to see what your audience prefers.

---

Scaling, analytics, and optimization

Once the basic workflow is stable, you can scale and optimize it using data:

• Track metrics like impressions, engagements, clicks, and follower