DEV Community: CDCSaaS

How to Migrate Off Clearbit to a Pay-Per-Success Enrichment API

CDCSaaS — Wed, 24 Jun 2026 12:37:52 +0000

Clearbit doesn't exist as a standalone product anymore — HubSpot folded it into Breeze Intelligence, and the plain Enrichment API a lot of us called directly is being wound down. If you're staring at a migration, here's a practical way to do it without breaking your pipeline or overpaying along the way. I build one of the alternatives, so I'll flag that clearly and stay honest about what a migration can and can't carry over.

Step 1: Split Clearbit into the two jobs it actually did

Clearbit bundled two very different things: company data (firmographics — sector, tech stack, country, legal name) and people data (contacts — names, work emails, phone numbers). Most replacements do one well, not both. So before you pick anything, audit which Clearbit fields you actually use:

If you only used company-level fields to qualify signups, route leads, or segment accounts — you need a firmographic API, and you can drop the contact database entirely.
If you relied on contact emails/phones — that's a separate purchase (Apollo, ZoomInfo), and no firmographic-only API will replace it. Being honest with yourself here saves money and rework.

Step 2: Map your fields

Clearbit field	Firmographic equivalent	Notes
`company.name`	`name`	read live from the site
`category.industry`	`sector`
`tech`	`tech_stack`	technographic
`geo.country`	`country`	often from official registry
`legalName`	`legal_name`	registry (FR/UK)
`foundedYear`	`founded_year`	registry
`metrics.employees`	—	not firmographic; needs a people/DB provider
`metrics.annualRevenue`	—	not available; don't fake it
`person.email`	—	contacts product, separate tool

The honest part of a migration is the bottom rows: employee count, revenue, and contacts don't come from a firmographic-by-domain API. If a vendor promises all of it cheaply, be skeptical.

Step 3: Pick a pricing model that survives a migration

During a migration you'll re-enrich your whole list — thousands of domains, many of them dead or parked. On a credit model where misses still cost you, that's money burned. Look for pay-per-success: billed only when the call returns real data. Worth saying honestly — this is becoming common (Clay, People Data Labs and Crustdata moved this way too), so treat it as a baseline to expect, not a unicorn.

Step 4: Re-enrich by domain, and handle the edge cases

The migration itself is usually a loop over domains. Two things Clearbit used to hide that you now want visible:

Dead/parked domains — check domain_status and skip enrichment for dead/parked instead of paying for empties.
Nulls — a good API returns null for what it can't verify; treat null as "unknown", never as a silent default.

Here's a real, live response (trimmed — tested in production while writing this):

{
  "domain": "free.fr",
  "firmographics": { "name": "Free", "legal_name": "FREE", "founded_year": 1999 },
  "tech": { "tech_stack": ["Nginx", "Next.js"], "domain_status": "active" },
  "data_sources": { "name": "web", "legal_name": "official_registry", "founded_year": "official_registry" },
  "meta": { "billed": true }
}

Notice data_sources and meta.billed: you can see where each field came from and whether the call was billable — exactly the visibility you want when you're re-running a big list and watching your spend.

What you can't carry over (and shouldn't pretend to)

To be blunt: a firmographic migration gives you company data, not people. Contacts, headcount and revenue need their own source. The clean mental model post-Clearbit is "firmographics here, contacts there" — two tools, each honest about its lane, instead of one black box you can't audit.

If the firmographic half is what you're migrating, you can try it on your own domains free — no signup for the first lookup: https://tools.coinduciel.com. Drop in a few of your real domains and check the field-by-field sources before you wire anything.

Disclosure: I build CDCSaaS, a firmographic-only enrichment API. I've kept the field mapping tool-agnostic where I can — if something looks off for your setup, tell me and I'll fix it.

Clearbit Shut Down Its Free Tier — The Honest Alternatives in 2026

CDCSaaS — Wed, 24 Jun 2026 12:23:53 +0000

If you came here because your Clearbit enrichment broke, you're not imagining it. HubSpot acquired Clearbit and folded it into Breeze Intelligence. The standalone Clearbit Enrichment API, the free tier, and the old logo/reveal endpoints have been sunset or pulled into the HubSpot ecosystem. If you were calling Clearbit as a plain API — outside HubSpot — you've effectively been orphaned.

This post is a straight, no-hype map of where to go next. I build one of the alternatives (more on that below, clearly flagged), so I'll be upfront about where my tool fits and where it doesn't — because picking the wrong category wastes weeks.

First, decide what you actually need

Most "Clearbit alternative" lists lump everything together. Don't. There are really two different jobs:

Contacts — names, work emails, phone numbers of decision-makers. This is people data.
Firmographics — company-level data: sector, description, tech stack, country, founded year, legal name, domain status. This is company data.

Clearbit did a bit of both, which is why its sunset hurts in two directions. Almost every alternative leans hard to one side. If you only need to know what a company is (to qualify a signup, route a lead, segment an account), you do not need a contact database — and you shouldn't pay for one.

A second axis matters too: how the data is sourced and billed.

Static database (refreshed monthly/quarterly) vs live (read at request time).
Subscription credits that expire vs pay only for successful calls.
Locked into a platform/CRM vs a plain API you call from anywhere.

The alternatives, honestly

Apollo.io — Contacts + company data + a sales-engagement platform. Its API enriches by email, domain, or LinkedIn URL and returns both contact and firmographic fields. Pick it if you genuinely need decision-maker contacts and outreach tooling in one place.

ZoomInfo — The enterprise heavyweight: huge contact database, intent signals, org charts. Pick it if you have an enterprise budget and need depth and coverage at scale.

People Data Labs — A developer API over a large company/person dataset (70M+ company profiles), strong on headcount. Database-backed, credit-based (you're charged on a successful response). Pick it if you need scale and headcount data via a clean API.

Crustdata — Real-time-leaning B2B data with 250+ company datapoints (headcount trends, funding, tech, web traffic) and webhook signals. Pick it if you want change signals (job changes, funding) and don't mind enterprise-ish pricing.

Clay — Not a data source but an orchestration layer that routes across 150+ providers and runs workflows. Since 2026 it no longer charges failed lookups. Pick it if you want a no-code table to combine many providers.

Enrich Layer — A developer-first API covering people, companies, and jobs, queryable by domain or name. Pick it if you want a broad unified API and are fine with subscription credits.

CDCSaaS (the one I build) — A small, honest firmographic-only API. You send a domain, you get live company data read from the site (name, sector, description, tech stack, socials, domain status) plus official-registry data for French (SIRENE) and UK (Companies House) companies (legal name, founded year, country, city). Every field is tagged with its source, and you're billed only when the call returns real data. Pick it if you only need company firmographics, you're tired of expiring credits and platform lock-in, and you value being able to audit where each field came from. Don't pick it if you need contact emails/phones — it doesn't do that, on purpose.

What "auditable" looks like in practice

Here's a real, live response for free.fr (trimmed for readability — tested in production while writing this):

{
  "domain": "free.fr",
  "firmographics": {
    "name": "Free",
    "legal_name": "FREE",
    "sector": "Télécommunications et services internet",
    "founded_year": 1999
  },
  "geo": { "country": "France", "city": "PARIS", "region": null },
  "tech": { "tech_stack": ["Nginx", "Next.js"], "domain_status": "active" },
  "data_sources": {
    "name": "web",
    "legal_name": "official_registry",
    "founded_year": "official_registry",
    "country": "official_registry",
    "tech_stack": "web"
  },
  "meta": { "fetched_at": "2026-06-21T20:32:41Z", "cached": true }
}

Two things worth copying as evaluation criteria, whatever tool you choose:

Provenance per field. Notice data_sources: name came from the website, but legal_name, founded_year and country came from the official registry. When a field is wrong, you know why. Most APIs hand you a flat blob with no idea where each value originated.
Explicit nulls. A field the API can't verify comes back null, not a guess. An API that "fills" every field is often inventing — and an invented country or sector is worse than a blank one, because you trust it.

So which should you pick?

Need contact emails/phones? Apollo or ZoomInfo. Stop reading the firmographic tools.
Need huge scale + headcount/funding signals? People Data Labs or Crustdata.
Want a no-code layer over many providers? Clay.
Just need clean, auditable company firmographics by domain — without a CRM, without credits that expire, without paying for misses? That's the lane CDCSaaS is built for.

There's no single "Clearbit replacement," because Clearbit was several products. The honest move is to name the one job you actually need done, then pick the tool that does that job well instead of the one with the longest feature list.

If firmographics-by-domain is your job, you can try CDCSaaS free — no signup for the first lookup: https://tools.coinduciel.com. Drop in a domain and you'll see the live data and its sources, same shape as above.

Disclosure: I build CDCSaaS. I've tried to keep the comparisons fair — if you spot something off about another tool here, tell me and I'll correct it.

How to Enrich a Google Sheet with Company Data Using n8n (No-Code Pipeline)

CDCSaaS — Sat, 13 Jun 2026 14:28:23 +0000

You have a spreadsheet full of website URLs. You want company names, industries, tech stacks, and contact emails — without spending hours on manual research.

Here's how to wire up a fully automated enrichment pipeline in about 20 minutes using n8n and a RapidAPI enrichment endpoint.

What you'll build

A 4-node n8n workflow that:

Reads a list of website URLs from a Google Sheet
Calls a company enrichment API for each URL
Writes back structured data (name, sector, description, contact email, tech stack) into the same sheet

No code. No server. Runs on demand or on a schedule.

Prerequisites

An n8n cloud account (free trial works)
A Google account (for Sheets)
A RapidAPI account subscribed to the AI Live Company Enrichment & Tech Detector API

Step 1 — Set up your Google Sheet

Create a new spreadsheet with these columns in row 1:

website | domain_status | fetched_at | company_name | sector | description | contact_email | tech_stack | linkedin

Add a few website URLs in the website column to test with:

https://stripe.com
https://notion.so
https://linear.app

Note your Spreadsheet ID from the URL — it looks like:
https://docs.google.com/spreadsheets/d/YOUR_SPREADSHEET_ID/edit

Step 2 — Connect credentials in n8n

You need two credentials before building the workflow.

Google Sheets OAuth2

In n8n, go to Credentials → New → Google Sheets OAuth2
Follow the OAuth flow to connect your Google account
Name it Google Sheets account

RapidAPI Header Auth

Go to Credentials → New → Header Auth
Set Name to x-rapidapi-key (exactly — this is the HTTP header name)
Set Value to your RapidAPI key
Save as RapidAPI – Company Enrichment

⚠️ Common mistake: setting the credential "Name" field to a display name like "My RapidAPI Key" instead of the actual header name x-rapidapi-key. n8n uses this field as the HTTP header name, so it must match exactly.

Step 3 — Build the workflow

Node 1: Manual Trigger

Add a Manual Trigger node. This lets you run the workflow on demand by clicking "Execute workflow." You can swap it for a Schedule trigger later.

Node 2: Google Sheets — Read

Add a Google Sheets node:

Operation: Read rows
Document ID: paste your Spreadsheet ID
Sheet: Sheet1 (tab index 0)
Credential: Google Sheets account

This node outputs one item per row — each item is a JSON object with your column values.

Node 3: HTTP Request — Enrich

Add an HTTP Request node:

Method: GET
URL:

  https://ai-live-company-enrichment-tech-detector.p.rapidapi.com/v1/enrich?url={{ $json.website }}

Authentication: Generic Credential Type → Header Auth
Credential: RapidAPI – Company Enrichment
Additional header: x-rapidapi-host = ai-live-company-enrichment-tech-detector.p.rapidapi.com

The {{ $json.website }} expression dynamically injects the URL from the previous node for each row. n8n automatically loops this node over all rows from the Sheets node.

Node 4: Google Sheets — Update

Add a second Google Sheets node:

Operation: Update row
Document ID: same Spreadsheet ID
Sheet: Sheet1
Matching column: website (used to find the right row)
Columns to update:

Column	Value
`website`	`{{ $json.url }}`
`domain_status`	`{{ $json.domain_status }}`
`fetched_at`	`{{ $json.fetched_at }}`
`company_name`	`{{ $json.data ? $json.data.company_name : "" }}`
`sector`	`{{ $json.data ? $json.data.sector : "" }}`
`description`	`{{ $json.data ? $json.data.description : "" }}`
`contact_email`	`{{ $json.data ? $json.data.contact_email : "" }}`
`tech_stack`	`{{ $json.data && Array.isArray($json.data.tech_stack) ? $json.data.tech_stack.join(", ") : "" }}`
`linkedin`	`{{ $json.data && $json.data.social_links ? $json.data.social_links.linkedin : "" }}`

The $json.data ? guards handle cases where the API returns null for a field — the cell just stays empty instead of crashing the workflow.

Connect the nodes

Wire them in sequence:

Manual Trigger → Google Sheets (Read) → HTTP Request (Enrich) → Google Sheets (Update)

Step 4 — Run it

Click Execute workflow. Watch the green checkmarks light up node by node.

After it completes, open your Google Sheet — each row should now have company name, sector, description, contact email, and tech stack filled in.

What the API returns

The enrichment endpoint returns a JSON object like this:

{
  "url": "https://stripe.com",
  "cached": false,
  "fetched_at": "2026-06-13T12:31:10.566368+00:00",
  "domain_status": "active",
  "data": {
    "company_name": "Stripe",
    "sector": "Financial Infrastructure and Payments",
    "description": "Stripe provides financial infrastructure enabling businesses to accept payments, offer financial services, and implement custom revenue models globally.",
    "contact_email": null,
    "tech_stack": ["Nginx", "Next.js"],
    "social_links": {
      "linkedin": "https://www.linkedin.com/company/stripe",
      "twitter": "https://twitter.com/stripe",
      "github": "https://github.com/stripe"
    }
  }
}

Three fields make this API stand out, and the workflow above captures them:

fetched_at — an ISO timestamp of when the site was actually read. Your sheet records exactly how fresh each row is, instead of trusting an invisible database refresh cycle.
domain_status — active, parked, or dead. Filter your sheet on this column to instantly drop dead or parked domains before they reach your CRM. A dead domain returns a clean 200 with data: null, so the workflow never crashes on a bad URL.
social_links — extracted deterministically from the live page, never guessed. A network that isn't present comes back null.

For well-known companies the data is usually complete. For smaller or less-indexed sites, some fields may be null — the API returns null rather than inventing a value, which is exactly why the guards in the expressions matter.

Going further

Schedule it: Swap the Manual Trigger for a Schedule Trigger to enrich new rows automatically every night.

Filter only empty rows: Add an IF node between the Read and Enrich nodes to skip rows that already have a company_name, saving API calls.

Drop dead domains automatically: Add an IF node after Enrich that keeps only rows where domain_status is active — parked and dead domains never reach your CRM.

Add error handling: Wrap the HTTP Request in an Error Trigger workflow to catch failed enrichments and log them to a separate sheet.

Export to a CRM: Add a HubSpot or Airtable node after the update step to push enriched companies straight into your sales pipeline.

The workflow JSON

You can import this directly into n8n (Workflows → Import from file). Replace YOUR_GOOGLE_SHEET_ID with your actual spreadsheet ID, then connect your credentials.

{
  "name": "Company Enrichment Pipeline",
  "nodes": [
    {
      "id": "node-001",
      "name": "Start",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [0, 0],
      "parameters": {}
    },
    {
      "id": "node-002",
      "name": "Google Sheets – Read",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.7,
      "position": [224, 0],
      "parameters": {
        "documentId": { "__rl": true, "mode": "id", "value": "YOUR_GOOGLE_SHEET_ID" },
        "sheetName": { "__rl": true, "mode": "id", "value": "0" },
        "options": {}
      }
    },
    {
      "id": "node-003",
      "name": "HTTP Request – Enrich",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [448, 0],
      "parameters": {
        "method": "GET",
        "url": "=https://ai-live-company-enrichment-tech-detector.p.rapidapi.com/v1/enrich?url={{ $json.website }}",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [{ "name": "x-rapidapi-host", "value": "ai-live-company-enrichment-tech-detector.p.rapidapi.com" }]
        },
        "options": {}
      },
      "credentials": { "httpHeaderAuth": { "name": "RapidAPI – Company Enrichment" } }
    },
    {
      "id": "node-004",
      "name": "Google Sheets – Update",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.7,
      "position": [672, 0],
      "parameters": {
        "operation": "update",
        "documentId": { "__rl": true, "mode": "id", "value": "YOUR_GOOGLE_SHEET_ID" },
        "sheetName": { "__rl": true, "mode": "id", "value": "0" },
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "website": "={{ $json.url }}",
            "domain_status": "={{ $json.domain_status }}",
            "fetched_at": "={{ $json.fetched_at }}",
            "company_name": "={{ $json.data ? $json.data.company_name : '' }}",
            "sector": "={{ $json.data ? $json.data.sector : '' }}",
            "description": "={{ $json.data ? $json.data.description : '' }}",
            "contact_email": "={{ $json.data ? $json.data.contact_email : '' }}",
            "tech_stack": "={{ $json.data && Array.isArray($json.data.tech_stack) ? $json.data.tech_stack.join(', ') : '' }}"
          },
          "matchingColumns": ["website"]
        },
        "options": {}
      },
      "credentials": { "googleSheetsOAuth2Api": { "name": "Google Sheets account" } }
    }
  ],
  "connections": {
    "Start": { "main": [[{ "node": "Google Sheets – Read", "type": "main", "index": 0 }]] },
    "Google Sheets – Read": { "main": [[{ "node": "HTTP Request – Enrich", "type": "main", "index": 0 }]] },
    "HTTP Request – Enrich": { "main": [[{ "node": "Google Sheets – Update", "type": "main", "index": 0 }]] }
  },
  "active": false,
  "settings": { "executionOrder": "v1" }
}

Why I built this

I'm building CDCSaaS — an API for enriching company profiles from a URL. This pipeline is one of the most common use cases: you have a list of leads or prospects as websites, and you need structured data about each one fast.

The n8n workflow makes it accessible to anyone — no Python, no ETL tooling, just a visual canvas and a few credential inputs.

If you try it, let me know in the comments what dataset you used it on. 👇

Part of the "Building CDCSaaS" series — documenting the build of a bootstrapped API product in public.

Turn any company website into structured B2B data (one API call)

CDCSaaS — Sat, 13 Jun 2026 00:08:28 +0000

If you've ever needed to go from a company's website to clean, structured data — its name, sector, a short description, social links, a contact email, and the technologies it runs on — you know the options aren't great:

Build your own scraper. Brittle, and every site is different. You'll spend more time maintaining selectors than using the data.
Pay a heavyweight data provider. Expensive, and the data is often a stale snapshot from months ago.
Paste HTML into an LLM and pray. Sometimes you get valid JSON. Sometimes you get a hallucinated CEO email that doesn't exist.

I kept hitting this wall while working with lists of company domains, so I built a small API that does one thing well: send a company URL, get back clean JSON.

The two rules that shaped it

1. It reads the live site at request time. Not a database snapshot from last quarter. If a company rebranded yesterday, you get today's version.

2. It never guesses. This was the hardest constraint to enforce with an LLM in the pipeline. Missing fields come back as null — never invented. If there's no contact email on the site, you get "email": null, not a plausible-looking fake you'd import straight into your CRM.

What a call looks like

curl --request GET \
  --url 'https://ai-live-company-enrichment-tech-detector.p.rapidapi.com/v1/enrich?url=https%3A%2F%2Fstripe.com' \
  --header 'x-rapidapi-host: ai-live-company-enrichment-tech-detector.p.rapidapi.com' \
  --header 'x-rapidapi-key: YOUR_KEY'

And the response:

{
  "url": "https://stripe.com",
  "cached": false,
  "data": {
    "company_name": "Stripe, Inc.",
    "sector": "Financial Technology / Payments",
    "description": "Stripe is a financial infrastructure platform for businesses...",
    "social_links": {
      "linkedin": "https://www.linkedin.com/company/stripe",
      "twitter": "https://twitter.com/stripe",
      "github": "https://github.com/stripe"
    },
    "contact_email": null,
    "tech_stack": ["React", "Next.js", "Cloudflare", "..."]
  }
}

How it works under the hood

A few design decisions, for the curious:

Two-pass tech detection. A fast pattern-matching pass first (think Wappalyzer-style fingerprints), then an LLM enrichment pass only for what patterns can't catch. Cheaper and faster than going full-LLM on everything.
Hard content trimming before the LLM. Page content is capped before any model call. This keeps latency and cost predictable instead of exploding on heavy JS-rendered sites.
Caching with a 14-day TTL. Repeat lookups on the same domain return in ~200 ms instead of re-scraping. The cached field in the response tells you which path you hit.
Strict schema validation. Every response is validated against a strict schema (Pydantic v2) before it leaves the API. Either the JSON conforms, or you get a proper error — never half-broken output.

Use cases I built it for

Lead enrichment: turn a list of prospect domains into CRM-ready records.
Tech-based targeting: filter prospects by their stack ("show me companies running Shopify").
Data hygiene: verify and refresh company records against the live web instead of stale databases.

Try it

There's a free tier (100 requests/month), enough to test it against your own data:

👉 AI Live Company Enrichment & Tech Detector on RapidAPI

I'd genuinely love feedback from other builders — on the positioning, the pricing, and especially: what field would you want it to extract next? Drop a comment below.