Skip to main content
Technical Guides

n8n Workflows with Rodz API: Intent Signal Automation

Peter Cools · · Updated on November 9, 2026 · 23 min read

TL;DR: n8n is an open-source workflow automation platform you can self-host or run in the cloud. Paired with the Rodz API, it lets you capture intent signals in real time and route them anywhere: CRM records, Slack alerts, enrichment pipelines, databases. This guide walks you through the full setup, from installing n8n to building production-ready workflows that react to signals the moment they fire.

What is n8n?

n8n (pronounced “n-eight-n”) is a workflow automation tool similar to Zapier or Make, with one notable difference: it’s open-source under a fair-code license. You can run it on your own server, inspect every line of code, and extend it with custom nodes. There’s also a hosted cloud version if you’d rather not manage infrastructure.

For teams that care about data sovereignty, cost control at scale, or deep customization, n8n is a strong choice. It supports over 400 integrations out of the box, has a visual workflow editor, and exposes a JavaScript/Python code node for anything the built-in nodes can’t handle.

In the context of the Rodz API, n8n is the orchestration layer. Rodz detects intent signals (fundraising rounds, job postings, leadership changes, competitor moves) and n8n decides what happens next: create a deal in your CRM, notify a sales rep, enrich the company data, or all three at once. The 48-hour window a signal stays actionable is tight enough that you want this routing to happen automatically, not manually.

Prerequisites

Before you start building, make sure you have the following ready:

  1. A Rodz account with API access. API access is available on all paid plans. Generate your API key from the Rodz dashboard under Settings > API Keys.
  2. A working n8n instance. Either self-hosted (Docker is the easiest path) or a cloud account at n8n.io.
  3. Basic familiarity with REST APIs. You should be comfortable reading JSON responses and setting HTTP headers. If you need a refresher, start with the Rodz API reference.
  4. A destination for your data. This could be HubSpot, Salesforce, Pipedrive, Slack, a Postgres database, or any tool that n8n connects to.
  5. cURL or Postman (optional but useful for testing API calls before wiring them into n8n).

If you’ve never made a call to the Rodz API before, work through the authentication and first request guide first. The rest of this article assumes you already have a valid API key and understand Bearer token authentication.

Step 1: Install and configure n8n

If you already have n8n running, skip to Step 2. Otherwise, the fastest path is Docker.

Self-hosted with Docker

Create a directory for n8n data, then run a single command:

mkdir -p ~/.n8n
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

Open http://localhost:5678 in your browser. You’ll see the n8n setup wizard. Create your admin account and you’re ready to build workflows.

For production deployments, add a reverse proxy (Traefik or Nginx) with TLS, set N8N_PROTOCOL=https, and configure a proper WEBHOOK_URL environment variable so that external services can reach your n8n instance. This is critical for receiving Rodz webhooks.

n8n Cloud

Sign up at n8n.io, create a workspace, and you’re ready. The cloud version handles TLS, uptime, and updates for you. The webhook URL is provisioned automatically.

Step 2: Store your Rodz API key as a credential

Never hardcode API keys inside workflow nodes. n8n has a built-in credentials system that encrypts secrets at rest.

  1. In the n8n UI, go to Settings > Credentials.
  2. Click Add Credential and choose Header Auth.
  3. Set the header name to Authorization and the value to Bearer YOUR_API_KEY.
  4. Name the credential something descriptive, like “Rodz API - Production”.
  5. Save.

You’ll reference this credential in every HTTP Request node that talks to the Rodz API. If you rotate your API key later, you only need to update it in one place.

Step 3: Poll signals with the HTTP Request node

The simplest integration pattern is polling. You ask the Rodz API for new signals on a schedule, then process the results.

Create the workflow

  1. Open n8n and click New Workflow.
  2. Add a Schedule Trigger node. Set it to run every 5 minutes (or whatever frequency fits your use case and rate limits).
  3. Add an HTTP Request node after the trigger.

Configure the HTTP Request node

Set the following parameters:

  • Method: GET
  • URL: https://api.rodz.io/v1/signals
  • Authentication: Select the “Rodz API - Production” credential you created.
  • Query Parameters:
    • created_after: Use an expression to send only the timestamp of your last poll. A simple approach is {{ $now.minus(5, 'minutes').toISO() }} to fetch signals created in the last 5 minutes.
    • limit: 50 (adjust based on expected volume).
    • type: Filter by signal type if you only care about specific categories, for example fundraising or job_posting.

The response is a JSON array of signal objects. Each signal contains the company name, signal type, metadata, and a timestamp.

Handle pagination

If your account generates a high volume of signals, the API uses cursor-based pagination. Check the response for a next_cursor field. If it exists, loop back and fetch the next page. In n8n, you can handle this with an IF node that checks for the cursor, feeding back into the HTTP Request node with the cursor query parameter set.

For a detailed explanation of pagination and rate limits, see the API reference guide.

Step 4: Receive signals in real time with webhooks

Polling works, but webhooks are better. Instead of asking the API every few minutes, the Rodz platform pushes signals to your n8n instance the moment they’re detected. That matters because a signal is only actionable for about 48 hours. Polling on a 5-minute cycle is fine; polling hourly is not.

Set up the webhook in n8n

  1. Add a Webhook node to a new workflow.
  2. Set the HTTP method to POST.
  3. Copy the webhook URL that n8n generates. It looks something like https://your-n8n-domain.com/webhook/abc123.
  4. Activate the workflow so the webhook endpoint is live.

Register the webhook with Rodz

Use the Rodz API to register your n8n webhook URL:

curl -X POST https://api.rodz.io/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-n8n-domain.com/webhook/abc123",
    "events": ["signal.created"],
    "active": true
  }'

You can subscribe to specific event types or receive all signals. For a full walkthrough of webhook configuration, event types, and retry behavior, read the webhook setup guide.

Validate incoming webhooks

Rodz signs every webhook payload with a signature header. In n8n, add a Code node immediately after the Webhook node to verify the signature:

const crypto = require('crypto');

const secret = $env.RODZ_WEBHOOK_SECRET;
const signature = $input.first().headers['x-rodz-signature'];
const payload = JSON.stringify($input.first().json);

const expected = crypto.createHmac('sha256', secret).update(payload).digest('hex');

if (signature !== expected) {
  throw new Error('Invalid webhook signature');
}

return $input.all();

Store RODZ_WEBHOOK_SECRET as an n8n environment variable. This ensures only legitimate payloads from Rodz get processed.

Step 5: Route signals to your CRM

Once signals are flowing into n8n (via polling or webhooks), the next step is routing them to the tools your team already uses.

Example: Create a HubSpot deal on fundraising signals

  1. After the HTTP Request or Webhook node, add a Switch node.
  2. Route based on the signal_type field. Create one output for fundraising, another for job_posting, and a fallback for everything else.
  3. On the fundraising output, add a HubSpot node.
  4. Set the operation to Create Deal.
  5. Map the signal fields to deal properties:
    • Deal name: {{ $json.company_name }} - Fundraising {{ $json.metadata.round }}
    • Amount: {{ $json.metadata.amount }}
    • Pipeline: Your outbound pipeline
    • Stage: “New Signal”

Example: Post to Slack on leadership changes

  1. On another Switch output (e.g., leadership_change), add a Slack node.
  2. Choose the channel where your sales team operates.
  3. Compose a message with the signal details:
New leadership change detected:
Company: {{ $json.company_name }}
Person: {{ $json.metadata.person_name }}
New role: {{ $json.metadata.new_title }}
Signal date: {{ $json.created_at }}

This gives reps immediate context without logging into another dashboard. The use case is simple: “I want to contact a company when a new C-level is appointed.” The n8n workflow is just the mechanical part of that.

Step 6: Enrich signals with additional data

Raw signals are useful. Enriched signals give your reps what they need to send one well-timed message instead of a follow-up sequence. The Rodz API exposes enrichment endpoints that let you pull additional company and contact data.

After receiving a signal, add another HTTP Request node:

  • Method: POST
  • URL: https://api.rodz.io/v1/enrich/company
  • Body:
{
  "domain": "{{ $json.company_domain }}"
}

The enrichment response returns firmographic data: employee count, industry, revenue range, technologies used, social profiles. Merge this with the original signal before pushing to your CRM, so reps have a complete picture without manual research.

You can chain multiple enrichment calls. After enriching the company, use the contact enrichment endpoint to find decision-makers and add them as contacts in your CRM.

Step 7: Add error handling and retries

Production workflows need to be resilient. n8n has several mechanisms for this.

Retry on failure

On any HTTP Request node, enable Retry On Fail in the node settings. Set the number of retries to 3 and the wait between retries to 5,000 ms. This handles transient network issues and temporary API rate limits without manual intervention.

Error workflow

Create a dedicated error workflow in n8n. Go to Settings > Error Workflow and point it to a workflow that sends a Slack message or email when any workflow fails. You’ll know immediately if a signal is missed.

Rate limit awareness

The Rodz API allows 100 requests per minute. If you’re processing a large backlog, add a Wait node between batches to stay under the limit. The API returns a 429 Too Many Requests status code with a Retry-After header when you exceed the limit. Your retry logic should respect that header.

Step 8: Monitor and maintain your workflows

Once your workflows are live, keep an eye on them.

  • Execution log: n8n stores execution history for every workflow. Review it periodically to catch silent failures (e.g., a CRM node that returns 200 but creates a duplicate record).
  • Workflow versioning: If you self-host n8n, back up your workflows by exporting them as JSON. Store those exports in version control alongside your application code.
  • Credential rotation: Rotate your Rodz API key periodically. Update the credential in n8n and no workflow node needs touching, since none of them reference the raw key directly.
  • n8n updates: Keep your n8n instance updated for security patches and new nodes. If you run Docker, it’s as simple as pulling the latest image and restarting the container.

n8n vs Make: which should you choose for Rodz?

Both n8n and Make are solid automation platforms. The right choice depends on your team’s priorities. Here’s a side-by-side comparison.

Criterian8nMake
HostingSelf-hosted or cloudCloud only
Pricing modelFree (self-hosted), cloud plans from ~$20/moFree tier, paid plans based on operations
Open sourceYes (fair-code license)No
Data sovereigntyFull control when self-hostedData on Make’s servers (EU/US)
Visual editorYes, node-based canvasYes, module-based canvas
Code nodesJavaScript and PythonLimited JavaScript in some modules
Built-in integrations400+1,500+
HTTP Request nodeFull-featured, supports auth credentialsFull-featured, supports auth credentials
Webhook supportNative, with signature validationNative, with built-in filters
Error handlingRetry logic, error workflows, dead-letter patternsError handlers per scenario, break directive
Learning curveModerate (more flexible, more to configure)Lower (more guided, less configuration)
CommunityActive open-source community, GitHub discussionsLarge user community, template library
Best for Rodz integrationTeams that want full control, custom logic, and no per-operation costsTeams that want a quick setup with minimal infrastructure management

If you want to self-host, need deep customization, or expect high signal volumes where per-operation pricing becomes expensive, go with n8n. If you’d rather have a managed service with more pre-built connectors and a gentler learning curve, Make is a strong option. The Rodz API works identically with both platforms.

For the Make integration guide, see Automate Intent Signals with Make and Rodz.

The same workflow in Make

What Is Make?

Make (formerly Integromat) is a visual automation platform that connects apps and services through “scenarios.” Each scenario is a pipeline: a trigger fires, data flows through modules (filters, routers, transformers, API calls), and actions execute at the end.

A few things make Make a good fit for signal automation specifically:

  • Visual builder. You drag modules onto a canvas and connect them. No scripting needed for most workflows.
  • Webhooks as triggers. Make provides instant webhook URLs you can register with Rodz. Every incoming payload kicks off your scenario in real time.
  • Router module. A single incoming webhook can branch into multiple paths based on conditions. One signal type goes to Slack, another to HubSpot, a third to Google Sheets.
  • Error handling. Built-in retry logic, error routes, and break directives mean your automation won’t silently fail.
  • Hundreds of integrations. Slack, HubSpot, Google Workspace, Notion, Airtable, email, HTTP/REST. If a service has an API, Make can talk to it.

Step 1: Create a Webhook Trigger in Make

Every Make scenario starts with a trigger. For real-time signals, you want a Custom Webhook trigger.

  1. Log into Make and click Create a new scenario.
  2. Click the large ”+” icon on the canvas, search for Webhooks, and select Custom webhook.
  3. Click Add to create a new webhook. Give it a descriptive name, such as “Rodz Intent Signals.”
  4. Make generates a unique URL. Copy it. You’ll need it in the next step.

Don’t close the scenario editor. Make is now listening on that URL and waiting for a sample payload so it can learn the data structure.

Step 2: Register the Webhook URL in Rodz

Now tell Rodz to send signal events to the Make webhook URL. You can do this with a single API call.

curl -X POST https://api.rodz.io/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hook.make.com/your-unique-id",
    "events": ["signal.created"],
    "description": "Make automation webhook"
  }'

Replace YOUR_API_KEY with your actual key and paste the Make webhook URL. The events array controls which events Rodz sends. signal.created covers all new signals. You can narrow this later.

Once you run this command, Rodz returns a webhook object with an id and a secret. Save the secret. You’ll use it to verify payloads if you add an HMAC check later (covered in the optimization section).

For a deeper walkthrough of webhook creation, payload structure, and retry behavior, see the full webhooks guide.

Step 3: Send a Test Payload

Make needs a sample payload to map fields. You can either wait for a real signal to fire or trigger a test event from the Rodz dashboard.

To trigger a test manually via the API:

curl -X POST https://api.rodz.io/v1/webhooks/YOUR_WEBHOOK_ID/test \
  -H "Authorization: Bearer YOUR_API_KEY"

Switch back to Make. The custom webhook module should now show the received data structure. You’ll see fields like signal_type, company.name, company.domain, signal.details, signal.detected_at, and more.

Click OK to confirm the structure. Make now knows how to parse every Rodz signal event.

Step 4: Route Signals by Type with the Router Module

This is where automation gets useful. A single webhook delivers all signal types: funding rounds, job postings, leadership changes, competitor mentions. You probably want different actions for each.

  1. Click the ”+” after the webhook module and search for Router. Add it.
  2. The router creates branches. Each branch gets a filter that checks a condition.
  3. Click the wrench icon on the first branch and set a filter: signal_type equals funding_round.
  4. Add a second branch with a filter: signal_type equals job_posting.
  5. Add a third branch with a filter: signal_type equals leadership_change.
  6. Add as many branches as you need. You can also create a fallback branch with no filter to catch any signal type not matched above.

Each branch now acts as an independent pipeline. A funding round signal flows down branch one and ignores the others. A job posting flows down branch two. This keeps your actions clean and targeted.

Useful filter examples

Filter conditionUse case
signal_type equals funding_roundNotify sales about new funding
signal_type equals leadership_change AND signal.details.role contains CTOAlert your technical sales team
signal_type equals job_posting AND signal.details.count greater than 5Spot companies on a hiring spree
company.industry contains SaaSFilter for your target vertical

Step 5: Add Action Modules

Connect each router branch to a destination. Here are the four most common actions.

Action A: Post to Slack

  1. On the funding round branch, click ”+” and search for Slack > Create a Message.
  2. Connect your Slack workspace if you haven’t already.
  3. Select the channel (e.g., #sales-signals).
  4. Build the message using mapped fields:
New funding signal detected
Company: {{company.name}}
Amount: {{signal.details.amount}} {{signal.details.currency}}
Round: {{signal.details.round_type}}
Detected: {{signal.detected_at}}
  1. Click OK. Every time a funding_round signal arrives, Slack gets a clean, structured notification within seconds.

Action B: Create or update a HubSpot contact/deal

  1. On a branch (e.g., leadership changes), click ”+” and search for HubSpot > Create/Update a Contact or Create a Deal.
  2. Map company.name to the company name property, signal.details fields to custom properties you’ve set up in HubSpot, and signal.detected_at to a date field.
  3. Use the Search module first to check if the company or contact already exists. Connect it with a router to either update or create.

For a more detailed HubSpot integration, see the dedicated guide: Connect Rodz to HubSpot.

Action C: Log to Google Sheets

  1. On a catch-all or specific branch, add Google Sheets > Add a Row.
  2. Connect your Google account and select the target spreadsheet and sheet.
  3. Map columns: Company Name, Signal Type, Details, Date Detected, Source URL.
  4. This creates a living log of every signal, useful for weekly reviews or reporting dashboards.

Action D: Send an email alert

  1. Add Email > Send an Email (or use Gmail, Outlook, or any mail module).
  2. Set the recipient to your sales manager or a distribution list.
  3. Build a subject line: [Rodz Signal] {{signal_type}}, {{company.name}}
  4. Body:
Hi team,

A new intent signal has been detected:

Company: {{company.name}}
Signal: {{signal_type}}
Details: {{signal.details.summary}}
Detected at: {{signal.detected_at}}

Review this signal in the Rodz dashboard or take action directly.
  1. Use this sparingly. Email works best for high-priority, low-volume signals. For high-volume signals, Slack or Sheets are better fits.

Three Ready-to-Use Scenarios

Here are three complete scenario blueprints you can build in under 15 minutes each.

Scenario 1: Funding alerts to Slack + Google Sheets

Trigger: Rodz webhook (Custom Webhook) Router branch 1: Filter signal_type = funding_round > Slack message to #funding-alerts > Google Sheets row append Router branch 2: All other signals > Google Sheets row append (different sheet tab)

Why it works: Your sales team sees funding rounds instantly in Slack while every signal gets logged for analysis. Two branches, four modules, about five minutes to build.

Scenario 2: Leadership changes to HubSpot + email

Trigger: Rodz webhook Filter: signal_type = leadership_change Step 1: HubSpot Search (find company by domain) Step 2a (found): HubSpot Update Company (add note with signal details) Step 2b (not found): HubSpot Create Company + Create Contact with the new leader’s details Step 3: Email notification to the assigned account owner

Why it works: Your CRM stays current without anyone manually entering data. When a new VP of Sales starts at a target account, HubSpot reflects it and the rep gets an email. That’s a warm introduction waiting to happen.

Scenario 3: Job posting surge to Slack + spreadsheet scorecard

Trigger: Rodz webhook Filter: signal_type = job_posting AND signal.details.count > 3 Step 1: Google Sheets, append row with company name, number of openings, roles, detected date Step 2: Slack message to #growth-targets with a summary

Why it works: A company posting four or more roles at once is growing fast. That’s a buying signal. By filtering on count, you skip one-off postings and focus on companies that are scaling, the ones most likely to need your product right now.

Optimization Tips

Once your scenarios are running, a few practices keep them fast, reliable, and cost-efficient.

Validate payloads with HMAC

Rodz signs every webhook payload with an HMAC-SHA256 signature using the secret from step 2. In Make, you can add a Webhook Response module or use a custom function to verify the X-Rodz-Signature header matches the computed hash of the body. This prevents spoofed requests from triggering your workflows.

Use filters aggressively

Every module in Make costs one operation. If you run a scenario on every signal but only care about funding rounds, you’re burning operations on signals you discard. Place filters as early as possible, right after the webhook trigger, to short-circuit irrelevant events before they hit downstream modules.

Set up error handling routes

Right-click any module in Make and select Add error handler. Use the Resume directive for transient failures (API timeouts) and Break for persistent ones (invalid credentials). The Break directive pauses the scenario and notifies you, so you can fix the issue before data piles up.

Batch logging with array aggregator

If you receive many signals in bursts, adding a row to Google Sheets for each one generates a lot of API calls. Use Make’s Array Aggregator module to collect signals over a short window, then write them all in a single Google Sheets > Add Multiple Rows call. This reduces operations and avoids hitting Google’s rate limits.

Monitor execution history

Make logs every scenario execution with timestamps, input/output data, and error details. Check this log weekly. Consistent filter misses may mean your signal configuration in Rodz needs adjusting. Repeated errors on a specific module usually point to expired credentials or a changed API schema.

Keep scenarios modular

Don’t build one massive scenario that handles everything. Create separate scenarios for separate concerns: one for Slack notifications, one for CRM updates, one for reporting. Register multiple webhooks in Rodz (one per scenario) or use a single webhook with Make’s router. Modular scenarios are easier to debug, update, and switch on and off independently.

Frequently asked questions

Does n8n have a native Rodz integration?

Not yet. Rodz is a REST API, so you connect to it using n8n’s built-in HTTP Request node. That node supports all HTTP methods, custom headers, query parameters, and request bodies. It works exactly like a native integration, just without a branded icon in the node picker. If the community builds a dedicated Rodz node later, it’ll simplify the setup, but the HTTP Request approach is fully production-ready today.

Can I self-host n8n and still receive Rodz webhooks?

Yes, but your n8n instance must be reachable from the public internet. Rodz webhook deliveries originate from Rodz servers, so they need a URL they can POST to. If you run n8n behind a firewall, set up a reverse proxy (Nginx, Traefik, or Caddy) with a valid TLS certificate and point your domain to it. Then use that public URL when registering the webhook with the Rodz API. Detailed instructions are in the webhook guide.

How do I handle rate limits when polling the Rodz API from n8n?

The Rodz API allows 100 requests per minute. If your polling workflow runs every 5 minutes and makes a single request per run, you’re well within the limit. For workflows that paginate through large result sets or chain multiple API calls (signals plus enrichment), add Wait nodes between requests or use n8n’s built-in “Retry On Fail” with exponential backoff. The API returns a 429 status code with a Retry-After header when the limit is exceeded. The API reference has the full rate limit details.

Can I use n8n to sync Rodz signals with multiple CRMs at the same time?

Yes. One of n8n’s strengths is parallel branching. After receiving a signal, add a Switch or IF node, then branch out to as many destinations as you need: HubSpot, Salesforce, Pipedrive, a Google Sheet, a Postgres database. Each branch runs independently, so a failure in one doesn’t block the others. This is useful for companies that run different CRMs across regions or business units.

What happens if my n8n instance goes down and misses a webhook?

Rodz retries failed webhook deliveries with exponential backoff over a 24-hour window. If your n8n instance is down for a few minutes, the retry mechanism will catch up once it’s back online. For extended outages, you can use the polling approach as a fallback: run a catch-up workflow that queries the Rodz API for signals created during the downtime window. Combining webhooks for real-time processing with a periodic polling safety net is a reasonable approach for mission-critical workflows.

Is n8n free to use with the Rodz API?

n8n is free if you self-host it. You can run it on any server, VPS, or even a Raspberry Pi. There are no per-operation fees, no execution limits, and no artificial throttling. The only costs are your server infrastructure and the Rodz API plan itself. The managed cloud version starts around $20 per month, which covers hosting, automatic updates, and support. Either way, there are no additional charges on the Rodz side for using n8n as your automation layer.

How do I test my n8n workflow before going live?

n8n has a built-in test mode. Click the “Test Workflow” button (or press the play icon on individual nodes) to run the workflow with real data without activating it permanently. For webhook-based workflows, n8n generates a test webhook URL that listens for a single incoming request. Trigger a test event from the Rodz dashboard or send a manual cURL request to the test URL, then inspect the output of each node in the execution panel. Once everything looks correct, activate the workflow and it’ll run automatically.

Can I version-control my n8n workflows?

Yes. n8n lets you export any workflow as a JSON file. Download the JSON, commit it to your Git repository, and you have a full history of changes. If you self-host, you can also use the n8n CLI to export and import workflows programmatically, which fits cleanly into CI/CD pipelines. This is worth doing if you maintain multiple environments (staging, production) and want to promote tested workflows through a review process before they go live.

Next steps

You have everything you need to connect n8n to the Rodz API and start routing intent signals automatically. A practical way to start: pick one signal type that matters most to your team (a fundraising round, a job posting surge, a leadership change), build a workflow that routes it to one destination, and run it for a week. Add enrichment once the basic flow is stable, then layer in error handling and expand to additional signal types.

For API endpoint details, consult the full API reference. To go through the interactive API documentation directly, visit api.rodz.io/docs.

Share:

Reach your prospects at the right moment, not randomly

Find the signals that fit your company and the tool that includes them.

Generate your outbound strategy for free

Our AI analyzes your company and creates a complete playbook: ICP, personas, email templates, call scripts.

Generate my strategy