WHOIS API for Lead Generation: Catch Newly Registered Domains

A new business usually registers its domain before it does anything else. Before the site goes live, before there’s a logo, before it shows up in any lead database. That registration date is the earliest public record of the business existing at all. The problem is timing: by the time a company lands in a prospecting tool, it’s already weeks old and getting pitched by everyone else. Using the WHOIS API for lead generation flips that around. You filter WHOIS records by registration date, pull the domains created in the last few days, and reach out while the business is still being established. This article covers the endpoint, the date filter, a one-request pull in Python, and a no-code version that runs itself every morning.

Why a registration date beats a lead list

Every day, registries add hundreds of thousands of new domains across all TLDs. Each one carries a created_datetime value: the moment the domain was first registered. That timestamp is about the freshest business signal you can get, and it’s public.

Why does that matter for outreach? A company that registered its domain three days ago is still in setup mode, sorting out hosting, a site, and the tools it’ll run on. If you sell any of that, or design or SEO or services, that’s the window when your message actually fits, and the inbox isn’t buried yet. Wait a month and the same lead has signed with someone else.

Most prospecting databases are weeks behind this because they wait for the site to go live, be indexed, or appear in some business registry. Registration data skips all of that. Filter by created_datetime, you’re reaching a business mere days after it’s established instead of months.

What DataForSEO WHOIS API returns for each domain

Our WHOIS Overview endpoint is part of the Domain Analytics API and pulls data from our WHOIS database of hundreds of millions of domains. For every domain that matches your filters, it returns the WHOIS record and enriches it with SEO and backlink signals. So you’re not looking at a bare domain string. You get enough context to decide whether it’s worth an email.

Each domain in the response includes:

That enrichment earns its place. A domain registered last week with no organic presence and no backlinks is a real greenfield lead. A week-old domain that already ranks for a few hundred keywords is probably a rebrand or a migration: still worth knowing about, just a different pitch. Either way, you read both facts off one response instead of stitching three tools together. For the full field reference, our guide on how to get domain age and WHOIS records covers it.

Filter WHOIS records by registration date

The filter you’ll use most is created_datetime. It’s a time filter, so you pass a full UTC timestamp (yyyy-mm-dd hh-mm-ss +00:00) and compare it with > or <. To get domains registered after August 12, 2026:

["created_datetime", ">", "2026-08-12 00:00:00 +00:00"]

You can stack up to eight filters with and / or logic, which is what turns the firehose into an actual lead list. A starting combination that works:

• created_datetime > (a few days ago) — the freshness window
• registered = true — skip lapsed or dropped registrations
• tld = "com" — narrow to the markets you sell into

Set order_by to created_datetime,desc so the newest domains come back first. One thing worth knowing: WHOIS ingestion runs a little behind real registration. So, query a rolling seven-day window and re-run it daily rather than asking for a single 24-hour slice. That way, you also catch domains that showed up a day or two late. The full list of WHOIS filters has every field you can sort and filter on.

Pull newly registered domains in one request

The snippet below pulls up to 1,000 domains registered in the last seven days: active only, .com only, newest first. It’s the smallest working version of the feed, the thing you’d later wrap in a scheduler or a queue once it returns what you expect. The response comes back as structured JSON, and each item carries the fields from the table above.

import base64
import requests
from datetime import datetime, timedelta, timezone

# Basic auth: base64 of "login:password" from https://app.dataforseo.com/api-access
auth = base64.b64encode(b"login:password").decode()

# WHOIS ingestion lags real registration slightly, so look back a few days
# and re-run daily instead of querying a single 24-hour window.
since = (datetime.now(timezone.utc) - timedelta(days=7)).strftime("%Y-%m-%d %H:%M:%S +00:00")

payload = [{
    "limit": 1000,  # up to 1,000 domains per request
    "filters": [
        ["created_datetime", ">", since],  # registered in the last 7 days
        "and",
        ["registered", "=", True],            # skip lapsed / dropped registrations
        "and",
        ["tld", "=", "com"]                   # narrow to the TLDs you sell into
    ],
    "order_by": ["created_datetime,desc"]     # newest registrations first
}]

resp = requests.post(
    "https://api.dataforseo.com/v3/domain_analytics/whois/overview/live",
    headers={"Authorization": f"Basic {auth}", "Content-Type": "application/json"},
    json=payload,
    timeout=120,
)

for item in resp.json()["tasks"][0]["result"][0]["items"]:
    print(item["domain"], item["created_datetime"], item["registrar"])

The endpoint is Domain WHOIS Overview. A single request returns up to 1,000 domains; for larger daily pulls, page through the results using the offset_token in the response.
Pricing is pay-as-you-go, so you only pay for the requests you actually make. Check our Domain Analytics WHOIS API pricing for the current per-request rate. That’s the data pull sorted. Now, to make it run on its own.

Automate the WHOIS API for lead generation with n8n

Nobody wants to run a script by hand every morning. The n8n blueprint below fires the same request on a daily schedule, then appends each new domain to a Google Sheet your team can work from. Import it, and you’ve got a sheet that fills itself with fresh domains every day, without anyone babysitting a script.

{
  "name": "Newly registered domains → Google Sheets",
  "nodes": [
    {
      "parameters": { "rule": { "interval": [{ "field": "days", "daysInterval": 1 }] } },
      "name": "Every day",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [260, 300]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.dataforseo.com/v3/domain_analytics/whois/overview/live",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpBasicAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "=[{ \"limit\": 1000, \"filters\": [[\"created_datetime\", \">\", \"{{ $now.minus({ days: 7 }).toFormat('yyyy-MM-dd HH:mm:ss') }} +00:00\"], \"and\", [\"registered\", \"=\", true], \"and\", [\"tld\", \"=\", \"com\"]], \"order_by\": [\"created_datetime,desc\"] }]"
      },
      "name": "WHOIS Overview",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [480, 300]
    },
    {
      "parameters": { "fieldToSplitOut": "tasks[0].result[0].items", "options": {} },
      "name": "Split domains",
      "type": "n8n-nodes-base.itemLists",
      "typeVersion": 1,
      "position": [700, 300]
    },
    {
      "parameters": {
        "operation": "append",
        "documentId": "YOUR_SHEET_ID",
        "sheetName": "Leads",
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "domain": "={{ $json.domain }}",
            "registered_on": "={{ $json.created_datetime }}",
            "registrar": "={{ $json.registrar }}",
            "tld": "={{ $json.tld }}"
          }
        }
      },
      "name": "Append to Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4,
      "position": [920, 300]
    }
  ],
  "connections": {
    "Every day": { "main": [[{ "node": "WHOIS Overview", "type": "main", "index": 0 }]] },
    "WHOIS Overview": { "main": [[{ "node": "Split domains", "type": "main", "index": 0 }]] },
    "Split domains": { "main": [[{ "node": "Append to Sheet", "type": "main", "index": 0 }]] }
  }
}

To get it running:

1. Sign up and copy your API credentials from the dashboard’s API access page.
2. In n8n, add an HTTP Basic Auth credential with your DataForSEO login and password.
3. Import the blueprint, connect a Google Sheets credential, and set your sheet ID.
4. Adjust the filters (TLD, look-back window) to match what you’re targeting.
5. Run it once by hand, confirm the rows land in your sheet, then switch on the daily schedule.

Prefer Make, or a plain cron job? Same idea. The moving parts don’t change: a schedule, one POST request, and somewhere to put the output.

Qualify before you reach out

Getting there first is the easy part. Not every new domain is a lead, though, and most teams trip on the same handful of things.

1. Treating every domain as a business. A lot of new registrations are parked, defensive, or placeholder domains that never become a real site. Filter on registered = true, and check epp_status_codes and the organic metrics before you drop one into a campaign.
2. Expecting contact details from WHOIS. Since GDPR, most registrant names and email addresses are already redacted, and this endpoint is built around the domain and its SEO signals rather than personal contact info. Treat the domain as your trigger, then find the actual contact through the site, LinkedIn, or an email finder. That part is the easy downstream step.
3. Emailing the same domain twice. Dedupe by domain and keep a record of what you’ve already pulled, tracking created_datetime or first_seen so a rolling window doesn’t hand you last week’s leads again.
4. Drowning in TLD noise. If you sell into a single region or segment, filter the TLD to match that region or segment. A short, well-filtered list beats a long, messy one.
5. Letting the feed go stale. The whole advantage here decays by the day, so a weekly run gives back most of that edge. Daily is the point.

Catch new businesses the moment they appear

A domain’s registration date is the earliest public sign that a business exists, and it’s one filter away. Point our WHOIS API at created_datetime, narrow by TLD and status, and WHOIS becomes a daily feed of companies that are days old instead of months into someone else’s pipeline. The data pull is one request. The automation is a handful of nodes. After that, the only thing left is to reach out first.

Try for free and start filtering WHOIS records by registration date today.