# AI Domain Name Generator & Availability Checker (`devcake/startup-domain-searcher`) Actor

Describe your idea, find brandable names, check available domains, compare GoDaddy prices, and choose the perfect name for your brand.

- **URL**: https://apify.com/devcake/startup-domain-searcher.md
- **Developed by:** [devcake](https://apify.com/devcake) (community)
- **Categories:** AI, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🤖 AI Domain Name Generator & Availability Checker

Generate 20-100 brandable website names with AI, check them across your preferred extensions, and compare a ranked shortlist in one workflow. The Actor combines AI naming, domain availability, public RDAP/WHOIS registration evidence, transparent scoring, GoDaddy purchase checks, and alternatives for unavailable domains.

▶️ [Try AI Domain Name Generator & Availability Checker on Apify](https://console.apify.com/actors/Fk1eY4sovlCTSICL4)

### ✨ What can you do with this Actor?

- 🤖 Generate up to 100 domain stems from a product or business description.
- 🎨 Guide the naming style, tone, language, length, or words to avoid.
- 🌍 Search across 1-10 popular or custom extensions such as `.com`, `.ai`, `.io`, or `.co.uk`.
- 🔎 Check up to 500 supplied domains or name stems instead of generating them.
- ✅ Classify every domain as `available`, `taken`, or `unknown`.
- 🪪 Run a WHOIS domain lookup with RDAP preferred and public WHOIS as fallback.
- 🛡️ Return registrar, dates, nameservers, DNSSEC, and statuses when public data is available.
- 💳 Check GoDaddy purchase availability and pricing for every run.
- 💡 Generate and registrar-check alternatives when requested names are unavailable.
- 🏆 Rank names by fit, pronunciation, memorability, brandability, length, and TLD availability.
- 🔌 Automate through Apify clients, REST API, schedules, and webhooks.

The Actor does not register domains, perform trademark clearance, or guarantee that a registrar will sell a name.

### 👥 Who is this domain name generator for?

Built for 🚀 founders, 🏢 business owners, 🎨 naming teams, 🔬 domain researchers, and 🧑‍💻 developers who need a scored, auditable domain shortlist or API workflow.

### 🎯 Use cases

#### AI domain name generator and checker

Generate 20-100 domain stems from a product brief, expand them across selected TLDs, check availability, and rank the results. Use the optional instructions field when you need a particular tone, language, length, or naming pattern.

#### Startup and business name generator

Turn a startup brief into domain-ready ideas. Compare fit and brandability, then see available extensions for each stem. This is domain research, not legal name validation.

#### WHOIS domain expiration lookup

The `registration` object can contain registrar, creation and expiry dates, nameservers, DNSSEC, and statuses. RDAP is preferred; WHOIS is the optional fallback.

#### Domain availability API

Run through REST, JavaScript, Python, Make, n8n, schedules, or webhooks. Export the dataset as JSON, CSV, or Excel.

### ⚙️ How it works

1. Describe your product, audience, and differentiator, or supply names you already have.
2. When no names are supplied, the configured AI model generates up to your selected maximum; the Actor expands and deduplicates stems across your selected extensions.
3. RDAP, DNS-over-HTTPS, and optional WHOIS classify and enrich domains.
4. GoDaddy adds purchase and renewal data. When a candidate is unavailable, the Actor can add purchasable AI or deterministic alternatives.
5. Candidates are scored, ranked, filtered if requested, and saved as one dataset item per fully qualified domain. The run summary is saved separately in the `SUMMARY` key-value-store record.

### 🎛️ Input

| Field | Default | Description |
|---|---:|---|
| `description` | Example prefill | Product, audience, and differentiator used for AI generation and fit scoring. Leave empty only when supplying `domainNames`. |
| `maxCandidates` | `20` | Maximum number of AI-generated names, from 20-100. Ignored when `domainNames` is supplied. |
| `generationInstructions` | Empty | Optional naming style, tone, language, length, or words to avoid. |
| `tlds` | `com` | One or more popular extensions used to expand generated names and supplied stems. |
| `additionalTlds` | Empty | Custom country-code or industry extensions. Leading dots are optional. |
| `domainNames` | Empty | Up to 500 full domains or stems to check instead of generating names. |

The public form groups these six controls into generation, customization, extension, and supplied-domain sections. Provide either `description` or at least one item in `domainNames`. Popular and custom extensions are combined and deduplicated, with a maximum of 10. A full domain such as `example.co.uk` is checked as supplied; a stem such as `example` is expanded across the selected extensions. Inputs that expand beyond 3,000 fully qualified domains are rejected.

AI credentials are managed by the Actor owner through encrypted environment variables. Users do not need to provide an AI key.

#### Legacy API and advanced inputs

For backward compatibility, the runtime still recognizes the controls below, but they are intentionally excluded from the public input schema and published task presets:

| Input | Behavior |
|---|---|
| `checkAvailability` | Availability checks are always enabled. This legacy flag is ignored. |
| `onlyAvailable` | Keep only results classified as `available`; summary counts still describe every checked candidate. |
| `includeRegistrationData`, `whoisFallback` | Control RDAP metadata and the optional public WHOIS fallback. Both are enabled by default. |
| `maxConcurrency`, `requestTimeoutSecs`, `requestRetries` | Control availability request concurrency, timeout, and retries. |
| `scoreWithAi`, `weights` | Disable AI scoring or override the six score weights: `length`, `pronounceability`, `memorability`, `brandability`, `zone`, and `fit`. Deterministic scoring remains available. |
| `aiProvider`, `apiKey`, `model` | Select a supported provider (`openrouter`, `groq`, `openai`, or `anthropic`) and optionally override the model. Environment keys are preferred. |
| `generationPrompt`, `scoringPrompt` | Customize AI generation and scoring instructions. |
| `checkRegistrarPricing` | GoDaddy availability and purchase/renewal pricing are always requested. This legacy flag is ignored. The Actor requires a residential or custom proxy configuration. |
| `onlyPurchasable`, `maxRegistrationPrice` | Filter by GoDaddy purchase status or purchase price. Both require `checkRegistrarPricing: true`. |
| `generateAlternatives`, `maxAlternatives`, `alternativeCheckLimit` | Control the default-on generation and registrar checking of purchasable alternatives for unavailable candidates. AI alternatives are used when an AI client is available, with deterministic fallbacks. |

Registrar options include `registrarMarket`, `registrarPageUrl`, `registrarRequestTimeoutSecs`, `registrarProxyConfiguration`, and `registrarStrict`. The API also accepts the older `includeRegistrarRecommendations` and `maxRegistrarRecommendations` aliases.

### 🚀 Example: generate startup domain names

```json
{
  "description": "An AI assistant that turns customer interviews into a prioritized product roadmap for SaaS teams",
  "maxCandidates": 20,
  "generationInstructions": "Prefer short, confident names that are easy to pronounce internationally",
  "tlds": ["com", "ai"],
  "additionalTlds": ["co.uk"]
}
```

### 📊 What data does it return?

| Field | Description |
|---|---|
| `domain`, `stem`, `tld`, `rank` | Domain identity and final position. |
| `availability`, `available` | Four-state status (`available`, `taken`, `unknown`, or `not_checked`) and a Boolean when availability is known. `available` is omitted for `unknown` and `not_checked`. |
| `evidence` | RDAP, DNS, registrar status, and methods used. Null subfields are omitted. |
| `registration` | RDAP/WHOIS registrar, handle, dates, nameservers, DNSSEC, and statuses when public registration data is found. The object is omitted when no data is available. |
| `registrar` | Optional GoDaddy availability, purchase/renewal pricing, premium/restricted flags, aftermarket data, and market metrics. |
| `scores`, `score`, `scorePercent` | Six component scores and weighted totals. |
| `availableTlds`, `zoneAvailability` | Availability for the same stem across selected extensions. |
| `source`, `description`, `domainUrl`, `checkedAt` | Candidate origin, input context, HTTPS domain link, and timestamp. |

Results are sorted with `available` first, then `unknown`, `not_checked`, and `taken`; score percentage, score, and domain name break ties. `rank` is assigned after any output filters. The `SUMMARY` record contains generated/checked/saved counts, status counts, registration count, AI and registrar configuration, and up to ten top available domains.

`registration` contains public registration infrastructure data. Fields without data are omitted instead of being returned as `null`.

```json
{
  "domain": "openai.com",
  "availability": "taken",
  "evidence": { "rdapStatus": 200, "method": "rdap" },
  "registration": {
    "source": "rdap",
    "registrar": { "name": "MarkMonitor Inc.", "id": "292" },
    "expiresAt": "2029-01-19T19:28:24Z",
    "nameservers": ["ns1-02.azure-dns.com", "ns2-02.azure-dns.net"],
    "dnssec": { "signed": false, "status": "unsigned", "dsData": [] }
  }
}
```

### 🔌 API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/devcake~startup-domain-searcher/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"description":"An observability tool that turns production traces into regression tests","tlds":["com","ai"]}'
```

### ❓ Frequently asked questions

#### Can I use AI to generate domain names?

Yes. Provide a description of your product, audience, and differentiator. The configured AI model generates valid lowercase stems, expands them across your selected extensions, checks availability, and ranks the results. The Actor owner supplies the encrypted provider key.

#### How does the WHOIS lookup work?

The Actor first requests RDAP, then uses WHOIS when RDAP has no record and DNS does not prove availability. Public results may include registrar, expiry, nameservers, and DNSSEC, but privacy redaction and registry policy can leave some values empty. These lookup settings are managed automatically.

#### Can I check domains I already have?

Yes. Add `domainNames` in the form or through the API. Full domains are checked as supplied; bare stems are expanded across `tlds`. This mode does not require an AI key unless you also request AI scoring or AI-generated alternatives.

#### Does the Actor check registrar prices?

Yes. Every run requests GoDaddy availability and purchase/renewal pricing through an Apify or custom proxy. Registrar failures can still fail soft unless `registrarStrict`, `onlyPurchasable`, or `maxRegistrationPrice` requires the pricing data.

#### How can I generate unique domain names?

Describe what the product does, who it serves, and what makes it different. The Actor normalizes and deduplicates AI suggestions before checking multiple extensions and ranking available candidates first.

# Actor input Schema

## `description` (type: `string`):

Describe what you offer, who it is for, and what makes it different. Leave this empty only when supplying domains in the advanced section.

## `maxCandidates` (type: `integer`):

Maximum number of AI-generated names. The total number of domain checks is names × extensions—for example, 100 names across 10 extensions checks up to 1,000 domains.

## `generationInstructions` (type: `string`):

Optional: guide the AI's naming style, tone, language, length, or words to avoid. Required domain-name rules still apply.

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

Choose popular extensions to check for every generated name. If omitted, the Actor uses com only. The number of checks equals names multiplied by extensions: 50 names across 5 extensions means 250 domain checks.

## `additionalTlds` (type: `array`):

Optional: add custom extensions such as country-code or industry-specific TLDs. Leading dots are optional. The combined total of popular and custom extensions must be 10 or fewer.

## `domainNames` (type: `array`):

Optional: check names you already have instead of generating with AI. Enter full domains such as example.com, or stems such as example to expand across the selected extensions. When provided, the business idea and number of names are ignored for generation.

## Actor input object example

```json
{
  "description": "An AI assistant that turns customer interviews into a prioritized product roadmap for SaaS teams",
  "maxCandidates": 20,
  "tlds": [
    "com"
  ],
  "additionalTlds": [],
  "domainNames": []
}
```

# Actor output Schema

## `results` (type: `string`):

All dataset items produced by the run.

## `summary` (type: `string`):

Counts, configuration, and the highest-ranked available domains.

# 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 = {
    "description": "An AI assistant that turns customer interviews into a prioritized product roadmap for SaaS teams"
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/startup-domain-searcher").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 = { "description": "An AI assistant that turns customer interviews into a prioritized product roadmap for SaaS teams" }

# Run the Actor and wait for it to finish
run = client.actor("devcake/startup-domain-searcher").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 '{
  "description": "An AI assistant that turns customer interviews into a prioritized product roadmap for SaaS teams"
}' |
apify call devcake/startup-domain-searcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,devcake/startup-domain-searcher"
        }
    }
}

```

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/Fk1eY4sovlCTSICL4/builds/iDLcR3txCV74QQ3cO/openapi.json