# Store Name Generator & .com Registry Checker (`automation-lab/ecommerce-store-name-domain-generator`) Actor

Generate ecommerce store name candidates from concepts and affixes, then check matching .com registration with public Verisign RDAP. Export names, rules and timestamped registry evidence; not a purchase guarantee.

- **URL**: https://apify.com/automation-lab/ecommerce-store-name-domain-generator.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 domain checkeds

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/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

## Store Name Generator & .com Registry Checker

This **store name generator** turns ecommerce concepts into repeatable name candidates and checks their matching .com domains against public Verisign RDAP. It exports the display name, domain, generation rule and timestamped registration evidence. A registry 404 means **not registered**, not guaranteed purchasable.

### What does it do?

Supply concepts such as coffee and velvet, optional prefixes and suffixes, or your own candidate names. The Actor combines words deterministically, removes duplicate domain labels, applies your constraints, and checks up to 100 candidates per run. No AI account, paid naming API or Shopify login is needed.

It does not scrape Shopify's naming tool, register domains, check trademarks or assess brand quality.

### Who is it for?

- Ecommerce founders screening a shortlist before launching a store.
- Agencies comparing naming directions for client projects.
- Researchers who need reproducible domain registration observations in a spreadsheet.

### Why use it?

Generation rules make each suggestion explainable. Source URLs and observation timestamps let you inspect registry evidence. Constraints are applied before lookup, so excluded names do not consume a checked-domain event. Supplying candidate names lets you compare your own shortlist under the same rules.

### Getting started

1. Enter one or more concepts, or supply candidateNames.
2. Adjust affixes, maximum domain label length and excluded substrings.
3. Set maxItems to bound the total candidates checked.
4. Run the Actor and inspect the default dataset.
5. Verify shortlisted domains at a registrar and perform trademark research independently.

Example input:

```json
{"concepts":["coffee","velvet"],"maxItems":20}
```

This finite rule set produces at most 14 unique candidates, not 20 automatically invented names.

### Input parameters

| Field | Default | Behavior |
| --- | --- | --- |
| concepts | Empty | Up to 50 concepts; provide these or candidateNames |
| candidateNames | Empty | Up to 50 supplied names, checked before generated names |
| prefixes | my, hello | Prepended to each concept; \[] disables |
| suffixes | shop, store, co | Appended to each concept; \[] disables |
| excludeTerms | Empty | ANY case-insensitive substring against label with spaces removed |
| maxDomainLength | 30 | 1–63 characters before .com; overlength candidates discarded |
| maxItems | 20 | Global unique candidate limit, 1–100; zero/unlimited unsupported |

Names and affixes accept ASCII letters, digits and spaces only. Whitespace is trimmed and repeated spaces collapsed; generation uses lowercase normalized values. Domain labels remove spaces. Do not provide URLs, punctuation, .com extensions or non-ASCII names. Invalid input fails before the start charge. Unsupported input fields are rejected rather than ignored.

### How generation works

Candidates are considered in this order: supplied names; bare concepts; each concept with suffixes then prefixes; ordered pairs of different concepts. Domains are deduplicated before lookup. Exclusions and label length apply to every route. Prefixes and suffixes have no effect without concepts.

Rank is this deterministic ordering, **not** a suitability score or availability ranking. No synonyms, language model suggestions or random mutations are generated. Tight filters may produce no candidates; that is a valid empty result with a start event only.

### Output data

| Field | Meaning |
| --- | --- |
| name | Title-cased display name |
| domain | Lowercase .com domain |
| generationRule | supplied_name, concept, concept_suffix, prefix_concept, concept_pair |
| rank | Generation order, starting at 1 |
| registryResult | registered, not_registered or unknown |
| httpStatus | Registry HTTP status; null if unavailable |
| checkedAt | Completed observation time in ISO format |
| sourceUrl | Public Verisign RDAP endpoint |
| error | Concise error for unknown; otherwise null |
| purchaseAvailability | Always not_checked |

### Output example

A real local lookup returned this Coffee record. Registration is observed at run time and can change.

```json
{
  "name":"Coffee",
  "domain":"coffee.com",
  "generationRule":"concept",
  "rank":1,
  "registryResult":"registered",
  "httpStatus":200,
  "checkedAt":"2026-10-02T14:24:27.259Z",
  "sourceUrl":"https://rdap.verisign.com/com/v1/domain/coffee.com",
  "error":null,
  "purchaseAvailability":"not_checked"
}
```

### How much does it cost to check store name domains?

The BRONZE price is a $0.005 start event plus $0.004 per conclusively checked domain. Per-domain prices by Store spend tier are FREE $0.0046, BRONZE $0.004, SILVER $0.00312, and GOLD/PLATINUM/DIAMOND $0.0024. These tiers reflect qualifying aggregate monthly Store spend, not a per-Actor volume discount.

Estimated total event charges at BRONZE: $0.009 for a one-result run, $0.045 for ten results, $0.105 for 25 results and $0.405 for 100 results. Consult the displayed price for your account. Both registered and not_registered observations count; unknown failed lookups have no item event. Name generation has no separate event charge. A valid run with no candidates has only the start event.

### Registration is not purchase availability

A matching RDAP domain object means registered. Verisign HTTP 404 with an empty RDAP-typed response or JSON errorCode 404 means not registered at observation time. Reserved, premium, restricted or recently changing names may still be unavailable to buy. We do not query registrar inventories, sales listings, DNS availability or trademarks. Do not interpret unknown as free.

### Limits and failure handling

Only .com registration is checked. Requests are sequential and spaced by 200 milliseconds. Network errors, HTTP 429 and server errors receive at most three attempts, with bounded backoff and a 15-second timeout per attempt. Persistent failure is recorded as unknown without an item charge. Other unexpected registry responses do not become not_registered.

If every attempted lookup fails, the run fails with diagnostic rows retained. Partial failures are visible in the dataset and SUMMARY key-value record. No proxy or browser fallback is enabled. A platform spending limit can stop output before maxItems. Registration observations are point-in-time, not a guarantee of future status.

### Integrations

Export the default dataset to JSON or CSV and compare shortlisted names in Google Sheets or your ecommerce planning system. n8n and Make can run the Actor, retrieve the dataset and filter registryResult to not_registered before human registrar verification.

Schedule repeated checks of the same supplied shortlist using Apify scheduling if you need fresh observations. The Actor itself does not retain historical comparisons, send alerts or purchase domains.

### API usage

Use your own Apify API token securely. Replace TOKEN without committing it to a repository.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ecommerce-store-name-domain-generator/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer TOKEN' -H 'Content-Type: application/json' \
  -d '{"concepts":["coffee","velvet"],"maxItems":10}'
```

JavaScript with the Apify client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ecommerce-store-name-domain-generator')
  .call({ concepts: ['coffee', 'velvet'], maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python with the Apify client:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ecommerce-store-name-domain-generator').call(
    run_input={'concepts': ['coffee', 'velvet'], 'maxItems': 10})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP use

Once the Actor is available to your account, configure Claude Code:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/ecommerce-store-name-domain-generator'
```

Claude Desktop, Cursor and VS Code can use this HTTP configuration (authenticate with your Apify account as required by the client):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/ecommerce-store-name-domain-generator"}}}
```

#### From an authorized run to bounded results

1. **Discover a stable tool subset.** Keep the Actor-specific URL above rather than a default/category selection that can grow. Actor selection also exposes `get-actor-run`, `get-dataset-items`, `get-key-value-store-record` and `abort-actor-run`; it is not exactly one tool. Use scoped `tools/list` to discover actual names and argument schemas (follow discovery pagination if provided), then use only the needed Actor/run/data tools. Discovery is read-only and does not authorize execution or aborting a run. Access depends on your account's Actor permissions.
2. **Start once and retain identifiers.** After authorizing the invocation, save the returned run ID, status and storage IDs. These are metadata, not the name/domain rows. If using `call-actor`, `waitSecs` is 0–45 seconds (default 30), so its return need not mean completion. For a nonterminal run, use `get-actor-run` on that same ID with 2, 4, 8-second backoff capped at 10 seconds and a total 120-second deadline. Set the client's request timeout above the selected server wait plus transport margin, within that deadline. On client timeout, recover/check the known run rather than restarting to poll. If its ID is unknown, report uncertainty; do not blindly rerun. At the deadline, stop and report pending with the run ID. Disclose terminal failure; any retained rows are partial, not a successful complete result.
3. **Retrieve bounded rows.** After success, call `get-dataset-items` with the returned `defaultDatasetId`, explicit `limit=20`, `offset=0`, and `fields` selecting `name,domain,registryResult,generationRule,checkedAt,error` in the discovered argument format. Prefer untransformed JSON. Page using source offsets and pagination metadata, not transformed row counts. Filtering or unwinding can change returned counts. Admit at most **100 rows or 64 KiB of serialized UTF-8 result content across all pages**, whichever comes first. These are example consumer context budgets, not changes to Actor collection limits or output.
4. **Enforce and disclose the budget.** A host capable of intercepting responses must count serialized bytes and rows before model injection, including an oversized single row/page; omit or summarize excess content with explicit disclosure. If your client cannot intercept responses before injection, the byte budget is only a target, not a hard guarantee: use small projected pages, never an unbounded request, and disclose that limitation. Stop at dataset exhaustion or budget. Report rows admitted, the next source offset and whether results are partial/truncated; preserve full JSON/CSV exports in Apify storage or downstream processing outside model context. Read SUMMARY through `get-key-value-store-record` when diagnosing unknown observations, rather than treating them as available domains.

Example prompt: “Generate up to ten coffee store name candidates and check their .com registry status. Start once and retain the run and dataset IDs. Follow that same run with bounded polling for at most 120 seconds. After success, retrieve projected pages of 20 with a total context target of 100 rows/64 KiB, enforced host-side where supported. Disclose pending, failed, partial or truncated results and any client budget limitation; provide the full export outside model context. Explain that not_registered is not a purchase guarantee.”

Actor-scoped hosted schema discovery was verified with authorized authentication. Tool discovery transport bytes are not necessarily model-visible context. Discovery caching, progressive tool loading and prompt caching depend on the client and negotiated capabilities; this recipe makes no universal or numeric token-savings promise. Such a claim would require a measured client/version, discovery/cache mode and capabilities, model/tokenizer, visible tool/result subset and baseline method.

### Legality and responsible use

Use bounded requests and respect registry terms. This tool provides technical observations, not legal advice or trademark clearance. Do not submit secrets as naming concepts.

Candidate domains are transmitted to the public Verisign registry; its service controls request-log retention. Run input, datasets, SUMMARY and logs remain in your Apify account under the platform/account retention policy; delete them through Apify when no longer needed. The Actor keeps no separate cross-run history. Do not submit personal data or secrets as naming input.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed and reports are retained for 30 days. For help, open an Actor issue on Apify or email automation_labs_support@agentmail.to.

### FAQ and troubleshooting

**Why did I get fewer names than maxItems?** The generation rules are finite. Deduplication, exclusions and length constraints can reduce output. Increase concept variety or supply more candidate names, not the cap alone.

**Can I use it as a Shopify store name generator?** Yes, for independent ecommerce naming research. It is not affiliated with Shopify and does not check Shopify account names.

**Why is a not_registered domain unavailable at my registrar?** RDAP is not a sales inventory. Verify restrictions, reserved names and price directly with the registrar.

**Why are rows unknown?** Registry lookups failed or returned unrecognized responses. Inspect error and httpStatus; do not assume availability. Rerun later only when the underlying failure has cleared.

**Can I check other extensions?** No. For broader supplied-domain registration research, use the related RDAP Actor.

### Related Actors

- [Domain Registration & RDAP Lookup](https://apify.com/automation-lab/domain-rdap-lookup): registration metadata for domains you already have.
- [Domain Name Extractor](https://apify.com/automation-lab/domain-name-extractor): normalize domain lists from text or public pages before further research.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/ecommerce-store-name-domain-generator/changelog.md

# Actor input Schema

## `concepts` (type: `array`):

Up to 50 ASCII letters/digits/space concepts; trimmed, lowercased, repeated spaces collapsed. Each concept is tried alone, with suffixes/prefixes, and as ordered pairs. Supply concepts or candidateNames.

## `candidateNames` (type: `array`):

Up to 50 names checked first, before generated names, under the same length/exclusion rules. ASCII letters/digits/spaces only; do not supply URLs or .com extensions.

## `prefixes` (type: `array`):

Affixes prepended to each concept, after suffix variants. Omit to use my and hello; an empty array disables prefixes. No effect without concepts.

## `suffixes` (type: `array`):

Affixes appended to each concept. Omit to use shop, store and co; empty array disables suffixes. No effect without concepts.

## `excludeTerms` (type: `array`):

ANY case-insensitive substring match against the normalized domain label, with spaces removed. Matching candidates are discarded before the limit; not whole-word or exact-field matching.

## `maxDomainLength` (type: `integer`):

Maximum characters before .com after spaces are removed; 1–63, default 30. Longer candidates are excluded, never truncated.

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

Global maximum unique candidate domains checked and emitted, 1–100, default 20; zero/unlimited unsupported. Supplied names precede concepts, affixed concepts and ordered concept pairs. Finite rules and exclusions can yield fewer rows; unknown rows count toward this limit.

## Actor input object example

```json
{
  "concepts": [
    "coffee",
    "velvet"
  ],
  "prefixes": [
    "my",
    "hello"
  ],
  "suffixes": [
    "shop",
    "store",
    "co"
  ],
  "excludeTerms": [],
  "maxDomainLength": 30,
  "maxItems": 20
}
```

# Actor output Schema

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

Inspect generated candidates, their generation rules, registry results and observation timestamps.

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

Counters for generated candidates, conclusive checks and unknown lookups.

# 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 = {
    "concepts": [
        "coffee",
        "velvet"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ecommerce-store-name-domain-generator").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 = {
    "concepts": [
        "coffee",
        "velvet",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ecommerce-store-name-domain-generator").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 '{
  "concepts": [
    "coffee",
    "velvet"
  ],
  "maxItems": 20
}' |
apify call automation-lab/ecommerce-store-name-domain-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ecommerce-store-name-domain-generator"
        }
    }
}
```

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/b9PFPGctE2O0N8bhE/builds/xQCcbiP1mRafgiwXM/openapi.json