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:

{"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.

{
  "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.

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:

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:

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:

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):

{"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: registration metadata for domains you already have.
• Domain Name Extractor: normalize domain lists from text or public pages before further research.