# Newly Registered Domains Feed: DNS & Website Check (`transparent_meteorite/newly-registered-domains-feed`) Actor

Daily newly registered domains from the free WhoisDS list, filtered by TLD and keyword, with an optional DNS A/MX check, mail provider, homepage status, title, site state and lead score. Domain names only, no registrant data.

- **URL**: https://apify.com/transparent_meteorite/newly-registered-domains-feed.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 domains

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Newly Registered Domains Feed: DNS & Website Check

Use this to get yesterday's newly registered domains, filtered by TLD and keyword, with an optional DNS and website check that tells you which new domains are already being set up as real businesses.

**One clean row per newly registered domain, from the free WhoisDS daily list (about 70,000 domains a day).** Most new domains sit unused for weeks. A web agency, a hosting or SaaS sales team, or a brand-protection analyst needs the few that matter: the ones that match a keyword, already have email (MX) set up, or already show a "coming soon" page. This actor downloads the day's list, filters it in seconds, and (if you want) checks each match over DNS-over-HTTPS and loads its homepage once.

- **What you get:** domain, Unicode form, TLD, list date, matched keyword, and with enrichment on: A record, MX record, server IP, MX hosts, mail provider (Google Workspace, Microsoft 365, Zoho, ...), nameserver, homepage HTTP status, final URL, page title, site state (live, placeholder, parked, for-sale, mail-only, no-dns ...) and a 0-100 lead score.
- **Who it is for:** web design and marketing agencies looking for brand-new businesses, hosting, email and SaaS sales teams, brand-protection and anti-phishing teams watching for lookalike names, domain investors and market researchers tracking naming trends.
- **Price:** $0.50 per 1,000 domains ($0.0005 each) without enrichment, $1.20 per 1,000 ($0.0012 each) for enriched domains that resolve in DNS, plus $0.00005 per run start. Enriched domains with no DNS records are charged the lower $0.0005 price. Filtered-out domains are never charged.
- **Domain names only, no personal data:** the WhoisDS free list contains no WHOIS records. This actor never queries WHOIS or RDAP contacts and never outputs registrant names, emails or phone numbers. E-mail addresses and phone numbers are stripped from page titles, and any row that still contains an e-mail address is dropped before it is saved or charged.
- **No login, no API key, no proxy.**

Real rows from our proof run on 2026-11-06 (run `62xNfTQn4zn7JHeue`, list date 2026-11-05, .com, prefilled keywords):

| Domain | Keyword | Has MX | Mail provider | HTTP | Site state | Lead score | Title |
|---|---|---|---|---|---|---|---|
| lobitzlaw.com | law | true | Google Workspace | 200 | live | 100 | HOME |
| allpinpointstudio.com | studio | true | Microsoft 365 | 200 | live | 100 | Pinpoint: AI Agents for Social Media Comments and DMs |
| solieststudio.com | studio | true | Hostinger | 200 | parked | 65 | Parked Domain name on Hostinger DNS system |
| getaquabearplumbing.com | plumb | false | | 200 | live | 65 | Plumbing Repair Service (title shortened) |
| unlikelyroadstudios.com | studio | false | | 200 | placeholder | 50 | Unlikely Road Studios - Different paths. One story (shortened) |
| rooferslittlerock.com | roof | false | | | no-dns | 10 | |

- **In short:** Newly Registered Domains Feed (Apify actor `transparent_meteorite/newly-registered-domains-feed`) returns the domains registered in the last day from the free WhoisDS newly registered domains list, filtered by TLD, include and exclude keywords, with an optional DNS A/MX check over DNS-over-HTTPS and a homepage status and title check.
- **Who it is for:** web agencies, hosting/email/SaaS sales teams, brand protection, anti-phishing, domain investors, market researchers.
- **Input:** list date (default yesterday, or "latest", or any past YYYY-MM-DD), TLDs, include keywords, exclude keywords, exclude all-digit or IDN domains, max domains (1 to 100,000; 5,000 with enrichment), enrich on or off, homepage check on or off, only resolving domains, parallel checks (1-10).
- **Output:** 18 flat fields per domain: domain, domainUnicode, tld, registeredDate, keywordMatched, enriched, hasA, hasMX, ipAddress, mxHosts, mailProvider, nameserver, httpStatus, finalUrl, title, siteState, leadScore, checkedAt.
- **Price:** $0.0005 per domain, $0.0012 per enriched domain that resolves in DNS, $0.00005 per run start. Pay per result, no subscription.
- **Limits:** domain names only (no WHOIS or registrant data). The free list covers about 70,000 new domains per day across all TLDs; it is not a complete zone-file feed.

**Key facts**

- Actor name: Newly Registered Domains Feed: DNS & Website Check
- Actor ID: `transparent_meteorite/newly-registered-domains-feed`
- Store page: https://apify.com/transparent_meteorite/newly-registered-domains-feed
- Data sources: WhoisDS free daily newly registered domains list; Cloudflare and Google public DNS-over-HTTPS resolvers; each domain's own homepage
- Pricing model: pay per event (`apify-actor-start` $0.00005, `domain` $0.0005, `enriched-domain` $0.0012)
- Output formats: JSON, CSV, Excel, XML, HTML table, RSS (Apify dataset)
- Access: Apify Console, REST API, JavaScript and Python clients, schedules, webhooks, Apify MCP server
- Login or third-party API key needed: no, only an Apify account
- Also known as: newly registered domains list, new domain registrations, NRD feed, fresh domains scraper, new domain leads, daily new domains by keyword, domain registration monitor
- Maintainer: transparent_meteorite (independent developer)
- Last updated: 2026-11-06

### What this newly registered domains feed does

1. Downloads the WhoisDS free newly registered domains list for the date you pick (one zip file, about 600 KB, about 70,000 domains).
2. Filters it by TLD, include keywords, exclude keywords, all-digit names and internationalized (xn--) names. Keywords match the name without the TLD, so `shop` does not match every `.shop` domain.
3. If enrichment is on, checks each matching domain:
   - **DNS A and MX** over DNS-over-HTTPS (Cloudflare first, Google as fallback, alternating to spread the load), plus the primary nameserver when the resolver returns it.
   - **Mail provider** from the MX hosts (Google Workspace, Microsoft 365, Zoho Mail, GoDaddy, Namecheap, Hostinger, IONOS, OVH, Cloudflare Email Routing, Proton, Fastmail and others).
   - **Homepage**: one GET of `https://domain/` (plain `http://` as fallback), at most 64 KB read, 8 second timeout, only for domains that have an A record. Returns the final HTTP status, final URL and the page title.
   - **Site state** and **lead score** (see below).
4. Writes one row per domain to the dataset and charges per row.

#### Site states

| siteState | Meaning |
|---|---|
| `live` | Homepage answered with a real page |
| `placeholder` | "Coming soon", "under construction", default server or blank CMS page: someone is building a site |
| `parked` | Registrar or parking-service page (GoDaddy lander, Namecheap, ParkingCrew, Sedo, Bodis and similar) |
| `for-sale` | The page says the domain is for sale |
| `http-error` | Homepage answered with HTTP 4xx or 5xx |
| `unreachable` | Has an A record but the homepage did not answer within 8 seconds |
| `mail-only` | Has MX (email) but no A record (no website yet) |
| `no-dns` | No A and no MX record yet |

#### Lead score (0-100)

A simple, transparent activity score, not a prediction: +15 A record, +25 MX record, +10 known mail provider, +30 live site or +25 placeholder site (+5 parked, error or unreachable), +10 live site with a title, +10 common business TLD (com, net, org, co, io, us, ca, uk, de, au, ai, biz, info, shop, store, agency, studio, llc). Domains for sale are capped at 10. A new domain with Google Workspace mail and a "coming soon" page scores 85: a business that is setting up and has no website yet. When both DNS resolvers fail for a domain, its DNS fields, site state and lead score are null (unknown), and it is charged the lower Domain price.

### Use cases

- A web design agency runs it every morning with keywords such as roofing, plumbing, dental, law, salon and realty, keeps `placeholder`, `parked` and `mail-only` rows with a lead score of 45 or more, and contacts the business through its future website or social profiles.
- A hosting, email or website-builder company schedules a daily run with `onlyResolving` on and routes new domains on a competitor's mail provider to its sales team.
- A brand-protection or security team runs it daily with its brand names and common misspellings as include keywords and alerts on every new lookalike domain that already has an A or MX record.
- A domain investor or market researcher pulls the full raw list (enrichment off, up to 100,000 rows) for a naming-trend analysis by TLD and keyword.
- An n8n, Make or Zapier workflow takes each new row, scores it with an AI step, and posts the best leads to Slack or a CRM for approval.

### Quick start: your first run in 30 seconds

1. Click **Try for free**. The input is prefilled with .com and eight local-business keywords, 25 domains, enrichment on.
2. Click **Start**. Our proof run of this input took 18 seconds.
3. Open the **Lead view** tab, sort by Lead score, and download CSV, JSON or Excel.

### Input options

| Field | Type | Default | What it does |
|---|---|---|---|
| `date` | string | yesterday (UTC) | WhoisDS list date, YYYY-MM-DD, or `latest`. Older lists are available too. |
| `tlds` | list | all | e.g. `com`, `io`, `shop`, `ai` |
| `includeKeywords` | list | none | Keep domains whose name contains one of these |
| `excludeKeywords` | list | none | Drop domains whose name contains any of these |
| `excludeNumericDomains` | boolean | false | Drop all-digit names |
| `excludeIdn` | boolean | false | Drop xn-- names |
| `maxItems` | integer | 100 | Rows to return (max 100,000 raw, 5,000 enriched) |
| `enrich` | boolean | true | DNS A/MX check (and homepage check) |
| `checkWebsite` | boolean | true | Homepage status and title for resolving domains |
| `onlyResolving` | boolean | false | Only return domains with an A or MX record |
| `maxConcurrency` | integer | 5 | Domains checked in parallel (1-10) |
| `maxRunSeconds` | integer | 900 | Stop cleanly after this many seconds |

#### Example input

```json
{
  "tlds": ["com"],
  "includeKeywords": ["roof", "plumb", "dental", "law", "realty", "salon", "cafe", "studio"],
  "excludeKeywords": ["casino", "bet"],
  "maxItems": 25,
  "enrich": true,
  "checkWebsite": true
}
```

Raw list only (cheapest), every TLD:

```json
{ "date": "latest", "enrich": false, "maxItems": 100000 }
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `domain` | string | Newly registered domain (ASCII / punycode) |
| `domainUnicode` | string or null | Unicode form for xn-- domains |
| `tld` | string | Top-level domain |
| `registeredDate` | string | Date of the WhoisDS list the domain appeared on (registered in about the 24 hours before) |
| `keywordMatched` | string or null | The include keyword that matched |
| `enriched` | boolean | DNS/website were checked |
| `hasA` | boolean or null | Has an IPv4 A record |
| `hasMX` | boolean or null | Has a mail (MX) record |
| `ipAddress` | string or null | First A record |
| `mxHosts` | list or null | Up to 5 MX host names |
| `mailProvider` | string or null | Provider inferred from MX hosts, or Other |
| `nameserver` | string or null | Primary nameserver from the SOA record, when returned |
| `httpStatus` | integer or null | Final homepage HTTP status |
| `finalUrl` | string or null | Homepage URL after redirects |
| `title` | string or null | Homepage title, emails and phone numbers removed |
| `siteState` | string or null | live, placeholder, parked, for-sale, http-error, unreachable, mail-only, no-dns |
| `leadScore` | integer or null | 0-100 activity score |
| `checkedAt` | string | When the row was produced (ISO 8601) |

Without enrichment, the enrichment fields are `null` and `enriched` is `false`.

### Sample output

```json
{
  "domain": "lobitzlaw.com",
  "domainUnicode": null,
  "tld": "com",
  "registeredDate": "2026-11-05",
  "keywordMatched": "law",
  "enriched": true,
  "hasA": true,
  "hasMX": true,
  "ipAddress": "103.169.142.6",
  "mxHosts": [
    "aspmx.l.google.com",
    "alt1.aspmx.l.google.com",
    "alt2.aspmx.l.google.com",
    "alt3.aspmx.l.google.com",
    "alt4.aspmx.l.google.com"
  ],
  "mailProvider": "Google Workspace",
  "nameserver": null,
  "httpStatus": 200,
  "finalUrl": "https://lobitzlaw.com/",
  "title": "HOME",
  "siteState": "live",
  "leadScore": 100,
  "checkedAt": "2026-11-06T06:18:23.689Z"
}
```

(A real row from the proof run above.)

### Pricing

Pay per event, no monthly rental:

| Event | Price | When it is charged |
|---|---|---|
| `domain` | $0.0005 ($0.50 per 1,000) | Each domain delivered without enrichment, or enriched but with no A or MX record |
| `enriched-domain` | $0.0012 ($1.20 per 1,000) | Each enriched domain delivered that has an A or MX record (charged instead of `domain`, not on top) |
| `apify-actor-start` | $0.00005 | Once per run |

Domains removed by your filters, domains skipped by `onlyResolving` and rows dropped by the privacy check are never charged.

**Worked example:** a daily agency run on .com with 8 keywords matched 377 domains on the 2026-11-05 list. With enrichment on and `maxItems` 200, about 21 in 25 resolved in our proof run, so assume about 170 of 200: 170 x $0.0012 + 30 x $0.0005 + $0.00005 = about $0.22 per day, about $6.60 per month. The same 200 domains without enrichment cost $0.10. The full raw list of about 70,000 domains costs about $35 (most users filter first).

**Worst case per run:** $0.00005 + `maxItems` x $0.0012. With the prefilled input (25 domains) that is $0.03005. You can lower it further with the "Maximum cost per run" setting in Apify Console, which the actor respects row by row.

### How to run it

#### In Apify Console

Fill in the input, click **Start**, and download the dataset from the **Output** tab.

#### From the API or a client library

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~newly-registered-domains-feed/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"tlds":["com"],"includeKeywords":["roof"],"maxItems":50}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("transparent_meteorite/newly-registered-domains-feed").call(run_input={"tlds": ["com"], "includeKeywords": ["dental"], "onlyResolving": True, "maxItems": 100})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["siteState"], row["leadScore"])
```

#### On a schedule

Create a daily schedule (for example 6:00 AM in your time zone) with the date left empty: each run takes yesterday's list, so you get each day's new domains exactly once.

#### With n8n, Make, Zapier or AI agents

Use the Apify integration for your tool, start the actor with your input, and read the dataset items. Each row is flat, with a stable `domain` key, a `registeredDate` and a numeric `leadScore` for filtering and sorting.

### Why use this instead of downloading the list yourself

- The raw file is just 70,000 names in a zip. This actor filters it by TLD and keyword in seconds and tells you which domains are already active.
- DNS and homepage checks are done for you, politely: a small worker pool (5 by default), DNS-over-HTTPS spread across two public resolvers, one homepage request per resolving domain.
- You only pay the higher price for domains that actually resolve.
- Rows are flat and typed, ready for CSV, a CRM or a workflow.

### Privacy and data scope

- The source list contains domain names only. This actor never queries WHOIS or RDAP contacts and does not output registrant, admin or tech contact names, emails, phone numbers or addresses.
- Page titles are cleaned of e-mail addresses and phone numbers. A whitelist of 18 fields is enforced, and any row containing an e-mail address in any field is dropped before it is saved or charged.
- The IP address is a server address from public DNS.

### Limits and honest caveats

- **Coverage:** the WhoisDS free list has about 70,000 newly registered domains per day across gTLDs and some ccTLDs. It is not a complete feed of every registration and not a zone-file diff.
- **Dates:** `registeredDate` is the list date. A domain on the 2026-11-04 list was registered in roughly the 24 hours before; exact registration timestamps are not in the source.
- **Fresh domains change fast:** a domain with no DNS today may be live tomorrow. Re-check later if you need a current state.
- **Site state is a heuristic** based on the page title, the first 64 KB of HTML and the nameserver. JavaScript-only sites can look blank, and some parking pages are not recognized.
- **Keyword matching is substring matching** on the name: `law` also matches `lawn`. Use exclude keywords to remove false matches.
- **IPv4 only** for `hasA` (no AAAA check).
- Enrichment is limited to 5,000 domains per run to keep the load on the public resolvers polite; split larger jobs by TLD or keyword.

### Data source and license

Domain list: WhoisDS free newly registered domains download (whoisds.com). WhoisDS states that the free daily lists may be reused, including for commercial purposes, without a license and without payment. DNS answers come from the Cloudflare (cloudflare-dns.com) and Google (dns.google) public DNS-over-HTTPS services. This actor is independent and not affiliated with or endorsed by WhoisDS, Cloudflare or Google.

### Related actors

- [Domain Intelligence Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup): deeper RDAP, DNS and hosting data for the domains you shortlist.
- [SSL Certificate Subdomain Finder](https://apify.com/transparent_meteorite/ssl-certificate-subdomain-finder): certificate transparency subdomains for a domain.
- [Website Contact Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): public business contact details from live websites.
- [Website Redesign Leads](https://apify.com/transparent_meteorite/website-redesign-leads): businesses whose existing websites need a refresh.
- [No-Website Business Email Finder](https://apify.com/transparent_meteorite/no-website-business-email-finder): local businesses without a website.

### FAQ

**How fresh is the data?** WhoisDS publishes a new list every day. Leave `date` empty to get yesterday's list (UTC), or use `latest` for the newest one published.

**Can I get older days?** Yes. Past list dates going back several months were available when we tested; if a date is not available the run ends with a clear message and costs only the start event.

**Does it give me the owner's name or email?** No. The source has no WHOIS data and this actor does not look it up. It is built for finding new domains and checking whether they are active, not for collecting personal data.

**Why is a domain marked no-dns?** Many domains are registered first and set up later. Run again in a few days, or turn on `onlyResolving` to receive only the domains that already resolve.

**How polite is the enrichment?** Five domains in parallel by default (maximum 10), two DNS queries each, spread over two public resolvers, and at most one homepage request per resolving domain with a 64 KB read limit.

**What does a run cost if nothing matches?** Only the $0.00005 start event.

**Can I monitor my brand for lookalike domains?** Yes. Put your brand name and common misspellings in `includeKeywords`, schedule a daily run, and alert on rows where `hasA` or `hasMX` is true.

### Troubleshooting

- **"No newly registered domains list is available":** the list for that day is not published yet. Use the day before or `latest`.
- **Zero rows:** your keywords or TLDs matched nothing on that day. Remove a filter or use shorter keywords.
- **Run stopped early:** the run hit `maxRunSeconds`, your maximum cost per run, or the compute guard (too little output for the work done). Delivered rows are complete.

### Terms and responsible use

Use the data for research, brand protection and business outreach that follows the laws that apply to you (for example CAN-SPAM, GDPR and PECR). Do not use it for unsolicited bulk messaging.

### Alternatives to Newly Registered Domains Feed

You can download the WhoisDS zip by hand and filter it in a spreadsheet, which works for a one-off look but not for daily DNS and website checks. Paid newly registered domain feeds include WHOIS data and full zone coverage under a subscription. Other Store actors in this niche price per row between about $0.001 and $0.01, or add a $0.10 start fee (checked 2026-11-05); this actor charges $0.0005 per domain and $0.0012 only for enriched domains that resolve.

### Use it from AI assistants (MCP)

Newly Registered Domains Feed works as a tool for AI assistants through the official Apify MCP server. Add this URL to any MCP client (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, VS Code):

```
https://mcp.apify.com/?actors=transparent_meteorite/newly-registered-domains-feed
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=transparent_meteorite/newly-registered-domains-feed",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Then ask, for example: "Which new .com domains registered yesterday mention dental and already have email set up?"

### Changelog

- **0.1 (2026-11-05):** first public version. WhoisDS daily list by date, TLD and keyword filters, DNS A/MX over DNS-over-HTTPS, mail provider, homepage status and title, site state, lead score, only-resolving mode, privacy whitelist, cost guard and run deadline.

### Support

Open an issue on the actor's Issues tab in Apify Console with your run id and the input you used. Feature requests are welcome, for example AAAA checks or extra mail providers.

# Actor input Schema

## `date` (type: `string`):

Day of the WhoisDS list, YYYY-MM-DD. Leave empty for yesterday (UTC; falls back to the day before if yesterday is not published yet). "latest" = newest published list. Older lists (months back) are also available.

## `tlds` (type: `array`):

Only these top-level domains, e.g. com, io, shop, ai. Empty = all TLDs.

## `includeKeywords` (type: `array`):

Keep a domain only if its name contains one of these (substring match on the name without the TLD, so "law" also matches "lawn"). Empty = keep all. The matched keyword is returned in keywordMatched.

## `excludeKeywords` (type: `array`):

Drop domains whose name contains any of these, e.g. casino, crypto, bet.

## `excludeNumericDomains` (type: `boolean`):

Drop names made only of digits and hyphens (e.g. 869632004.xyz).

## `excludeIdn` (type: `boolean`):

Drop punycode / non-Latin domains.

## `maxItems` (type: `integer`):

Maximum rows to return (and charge). Up to 100,000 without enrichment, 5,000 with enrichment.

## `enrich` (type: `boolean`):

DNS A + MX lookup over DNS-over-HTTPS (Cloudflare, Google as fallback), plus homepage status and title when the domain resolves. Rows that resolve are charged the Enriched domain price, all others the Domain price. Off = domain list only, cheapest.

## `checkWebsite` (type: `boolean`):

One GET of the homepage per resolving domain (64 KB cap, 8 s timeout). Turn off for DNS only.

## `onlyResolving` (type: `boolean`):

Return only domains with an A or MX record. Non-resolving domains are skipped and not charged. Checks up to 6x Max domains candidates.

## `maxConcurrency` (type: `integer`):

Domains checked in parallel (1-10). The default 5 keeps the load on the public resolvers polite.

## `maxRunSeconds` (type: `integer`):

The run stops cleanly and keeps delivered rows after this many seconds.

## Actor input object example

```json
{
  "tlds": [
    "com"
  ],
  "includeKeywords": [
    "roof",
    "plumb",
    "dental",
    "law",
    "realty",
    "salon",
    "cafe",
    "studio"
  ],
  "excludeKeywords": [],
  "excludeNumericDomains": false,
  "excludeIdn": false,
  "maxItems": 25,
  "enrich": true,
  "checkWebsite": true,
  "onlyResolving": false,
  "maxConcurrency": 5,
  "maxRunSeconds": 900
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `leads` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tlds": [
        "com"
    ],
    "includeKeywords": [
        "roof",
        "plumb",
        "dental",
        "law",
        "realty",
        "salon",
        "cafe",
        "studio"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/newly-registered-domains-feed").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "tlds": ["com"],
    "includeKeywords": [
        "roof",
        "plumb",
        "dental",
        "law",
        "realty",
        "salon",
        "cafe",
        "studio",
    ],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/newly-registered-domains-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tlds": [
    "com"
  ],
  "includeKeywords": [
    "roof",
    "plumb",
    "dental",
    "law",
    "realty",
    "salon",
    "cafe",
    "studio"
  ],
  "maxItems": 25
}' |
apify call transparent_meteorite/newly-registered-domains-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/newly-registered-domains-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DDkZ1YzunGgG0oj4I/builds/B3tqVK2eEhJ6XgBja/openapi.json