How to Enrich New Leads in Parallel from Multiple REST Sources

Build a Spojit workflow that captures a new lead, fans out three concurrent enrichment calls to external REST APIs, merges the results, scores fit with AI, and lands a fully enriched record in Monday.com.

What This Integration Does

When a new lead arrives with little more than an email address and a company domain, your sales team usually has to look up the company size, check the social and web presence, and figure out what technology the company runs before deciding whether the lead is worth a call. This workflow does all of that automatically in the time it takes to make a single API round trip. It captures the lead from a Webhook trigger, calls three separate enrichment vendors at the same time through the http connector, combines everything into one profile, asks an Agent-mode Connector node to score the fit, and creates a ready-to-work item on a Monday.com board.

The run starts when an external system POSTs a lead to the workflow's webhook URL. A Parallel node runs three independent http-get calls concurrently so total latency is roughly the slowest single call rather than the sum of all three. A Transform node merges the three branch outputs into one object, a Connector node in Agent mode scores the lead against a fixed Response Schema, and a final Monday.com create-item writes the record. Each lead produces one new Monday.com item; if the same lead is sent twice you get two items unless you turn on the trigger's event-id dedup, so re-runs are additive rather than idempotent by default.

Prerequisites

A Monday.com connection added in Spojit (Connections → Add connection), with access to the board where leads should land. Note the board's numeric ID and the relevant column IDs.
A Webhook signing connection (scheme Spojit or Custom) so the inbound lead POST can be verified.
API endpoints and keys for the external enrichment vendors you want to use (firmographics, social presence, and tech-stack signals). These do not need native connectors: the http connector reaches any REST API.
The destination board's column IDs for the fields you plan to write (company name, employee count, fit score, status).

Step 1: Capture the lead with a Webhook trigger

Add a Trigger node and set its type to Webhook. Pick the signing connection from your prerequisites so Spojit verifies the inbound POST. Copy the generated workflow URL and configure your lead source (a landing-page form handler, your marketing platform, or a system POST) to send a small JSON body such as:

{
  "email": "ada@example-corp.com",
  "domain": "example-corp.com",
  "source": "pricing-page"
}

The trigger returns 202 with an executionId and exposes the parsed body downstream. You can reference the domain as {{ input.domain }} and the email as {{ input.email }} in later steps.

Step 2: Fan out three enrichment calls with a Parallel node

Add a Parallel node directly after the trigger and give it three branches. Each branch holds one Connector node on the http connector in Direct mode using http-get. Because the branches run concurrently, the node finishes when the slowest branch finishes, not when all three have run in sequence.

Branch 1 (firmographics): call your firmographics vendor's REST API, for example https://api.firmographics-vendor.com/v1/company?domain={{ input.domain }}, and pass the API key in the Authorization header. Bind the result to firmographics.

Branch 2 (social presence): call your social-data vendor at a URL such as https://api.social-vendor.com/companies?domain={{ input.domain }}, again with its own key in the Authorization header. Bind the result to social.

Branch 3 (tech-stack signals): call your tech-detection vendor, for example https://api.techstack-vendor.com/lookup?domain={{ input.domain }}. Bind the result to techstack.

For each http-get call, set the URL, add headers as key/value pairs, and (if needed) any query parameters. The response body of each call is available on that branch's output, for example {{ firmographics.body }}.

Step 3: Merge the branch results with a Transform node

After the Parallel node, add a Transform node to combine the three branch outputs into a single flat profile object. Map fields from each branch into one shape so the next step has a clean, predictable input:

{
  "email": "{{ input.email }}",
  "domain": "{{ input.domain }}",
  "companyName": "{{ firmographics.body.name }}",
  "employeeCount": "{{ firmographics.body.employees }}",
  "industry": "{{ firmographics.body.industry }}",
  "linkedinFollowers": "{{ social.body.linkedin.followers }}",
  "websiteTraffic": "{{ social.body.traffic.monthlyVisits }}",
  "technologies": "{{ techstack.body.detected }}"
}

Bind the output to profile. If a vendor sometimes omits a field, the json connector helps here: use get with a default to read a nested value safely, or pick to keep only the keys you care about before merging. This keeps the merged profile stable even when one vendor returns a sparse response.

Step 4: Score fit with a Connector node in Agent mode

Add a Connector node in Agent mode. Agent mode lets the agent reason over the combined profile and return a judgment, and its Response Schema forces a clean JSON result you can map directly into Monday.com. In the prompt, pass the merged profile and describe your ideal-customer criteria, for example: "Score this lead from 0 to 100 for fit with a mid-market B2B SaaS buyer, given {{ profile }}. Favor companies with 50 to 1000 employees and modern web technologies."

Set a Response Schema so the output is structured and predictable:

{
  "type": "object",
  "properties": {
    "fitScore": { "type": "number" },
    "tier": { "type": "string", "enum": ["A", "B", "C"] },
    "rationale": { "type": "string" }
  },
  "required": ["fitScore", "tier", "rationale"]
}

Bind the output to score. You can then reference {{ score.fitScore }}, {{ score.tier }}, and {{ score.rationale }} downstream. Agent mode costs AI credits, so reserve it for the judgment step rather than the deterministic lookups.

Step 5: Create the enriched record in Monday.com

Add a Connector node on the monday connector in Direct mode and select create-item. Set the boardId to your destination board and the itemName to the company name, then map the enriched values into the board columns. For example:

{
  "boardId": "1234567890",
  "itemName": "{{ profile.companyName }}",
  "columnValues": {
    "text_email": "{{ profile.email }}",
    "numbers_employees": "{{ profile.employeeCount }}",
    "numbers_fit_score": "{{ score.fitScore }}",
    "status_tier": "{{ score.tier }}",
    "text_rationale": "{{ score.rationale }}"
  }
}

Use the exact column IDs from your board (not their display labels). If you want a follow-up note on the new item, chain a second Monday.com node with create-update referencing the new item's ID from the create-item output.

Step 6: Acknowledge the caller with a Response node (optional)

If your lead source expects a synchronous reply rather than just the 202 acknowledgment, add a Response node at the end to return a small confirmation body, for example { "status": "enriched", "tier": "{{ score.tier }}" }. Keep the upstream work fast so the caller does not time out, since enrichment vendors and the scoring step all add latency.

Tips

Keep the three lookups in the Parallel node so latency is bounded by the slowest vendor. Adding a fourth source is as simple as adding a fourth branch with another http-get.
Set a sensible request timeout on each http-get so one slow vendor does not stall the whole run. Treat a missing response as "unknown" in the Transform step rather than failing the branch.
Use the json connector's get with defaults or pick to normalize each vendor's response before merging, so the scoring prompt always receives a consistent shape.
Ask Miraxa, the intelligent layer across your automation, to scaffold this for you with a prompt like "Add a Parallel node with three http-get branches keyed on {{ input.domain }}, then a Transform node that merges their bodies," then fine-tune fields in the properties panel.

Common Pitfalls

Re-sent leads create duplicates. The Webhook trigger is additive by default. If your source may retry, enable the trigger's event-id dedup header so the same lead does not produce two Monday.com items.
Vendor schema drift. Enrichment APIs change response fields without notice. Reading nested values directly (firmographics.body.x.y) breaks silently; prefer json get with a default so the workflow degrades gracefully.
Wrong Monday.com column references. create-item expects column IDs, not the human-readable column titles. Pull the IDs from the board before mapping, or list the board with get-board to confirm them.
Over-using Agent mode. Only the scoring step needs Agent mode. Keep the three lookups and the Monday.com write in Direct mode to avoid spending AI credits on deterministic calls.

Testing

Before pointing real traffic at the webhook, send one test POST with a known domain (a company you can verify by hand) and watch the run in the execution history. Confirm that all three branches of the Parallel node returned a body, that the Transform node produced a complete profile, that the Agent-mode step returned a value matching your Response Schema, and that a single new item appeared on the Monday.com board with the right columns populated. Once one lead lands cleanly, enable the workflow and let your lead source send live traffic.