Namegrep APInamegrep.com ↗
Search available domain names across .com, .net, .org, .co, and .io using regex patterns. Returns per-TLD availability for up to 50,000 matching labels.
What is the Namegrep API?
The Namegrep API exposes 2 endpoints for finding available domain names using regular expression patterns. The search_domains endpoint matches PCRE-style patterns against a domain label dictionary and returns each matching name alongside boolean availability flags for five TLDs: .com, .net, .org, .co, and .io. Results cover up to 50,000 labels per query, making it practical for bulk domain prospecting and brand research workflows.
curl -X GET 'https://api.parse.bot/scraper/cc2caa1d-c089-4f45-b72e-ba4b4e94cdf8/search_domains?pattern=%5Ecloud%5Ba-z%5D%7B2%7D%24' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace namegrep-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: NameGrep SDK — bounded, re-runnable; every call capped."""
from parse_apis.NameGrep_API import NameGrep, ParseError
client = NameGrep()
# Quick count to estimate how many results a broad pattern produces
estimate = client.domains.count(pattern="[a-z]{5}")
print("5-letter combinations:", estimate.count)
# Search for 6-letter domain names starting with "cloud"
for domain in client.domains.search(pattern="^cloud[a-z]{2}$", limit=3):
print(domain.name, domain.com_available, domain.net_available, domain.io_available)
# Get the first result for a narrower pattern
result = client.domains.search(pattern="^data[a-z]{3}$", limit=1).first()
if result:
print(result.name, result.com_available, result.org_available, result.co_available)
# Typed error handling
try:
narrow = client.domains.count(pattern="^zen[a-z]{2}$")
print("zen* count:", narrow.count)
except ParseError as e:
print(f"error: {e}")
print("exercised: domains.search, domains.count")
Regex search over the domain-name dictionary. Returns all matching second-level labels (up to 50,000) with per-TLD registration status for .com, .net, .org, .co, and .io. The pattern is a PCRE-style regex matched against the full label (anchor with ^ and $ for exact length). Results are returned in a single page ordered alphabetically.
| Param | Type | Description |
|---|---|---|
| patternrequired | string | Regular expression pattern to match domain names against (e.g. '^tech[a-z]{2}$' for 6-letter names starting with 'tech'). Must produce fewer than 50,000 matches. |
{
"type": "object",
"fields": {
"count": "total number of matching domain names",
"domains": "array of domain objects with name and per-TLD availability booleans"
},
"sample": {
"data": {
"count": 676,
"domains": [
{
"name": "techaa",
"co_available": true,
"io_available": true,
"com_available": false,
"net_available": true,
"org_available": false
},
{
"name": "techab",
"co_available": true,
"io_available": true,
"com_available": false,
"net_available": false,
"org_available": true
}
]
},
"status": "success"
}
}About the Namegrep API
What the API Returns
The search_domains endpoint accepts a pattern string — a PCRE-style regular expression matched against second-level domain labels. The response contains a count of total matches and a domains array where each object includes the label name plus five boolean fields indicating current registration status for .com, .net, .org, .co, and .io. Anchoring the pattern with ^ and $ constrains exact length, which is useful when targeting, say, all unregistered five-letter .io names starting with a specific prefix.
Estimating Query Scale Before You Run It
The count_combinations endpoint takes the same pattern input but returns only the count of matching labels — no availability data. This is the right call to make first when your pattern might be broad: search_domains caps results at 50,000, so if count_combinations returns a number larger than that, you know the full search will be truncated and you should tighten your regex before proceeding.
Pattern Design and Coverage
Patterns follow PCRE conventions. Examples like ^tech[a-z]{2}$ match all six-character labels beginning with "tech". The underlying dictionary covers the label portion only — not subdomains or full URLs. TLD availability is reported as a boolean per domain object, so downstream filtering (e.g. keep only labels where .com is available) happens on the response array client-side. There is no server-side filter parameter to restrict results to a specific TLD.
The Namegrep API is a managed, monitored endpoint for namegrep.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when namegrep.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official namegrep.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Find all available .io domains matching a specific character pattern for a startup brand search
- Enumerate unregistered short domains fitting a regex template for bulk registration tools
- Pre-validate domain label patterns before committing to a naming convention across a product line
- Build a domain suggestion widget that surfaces available alternatives based on a name structure
- Screen for keyword-based domain availability across all five supported TLDs in one request
- Estimate the breadth of a naming pattern using count_combinations before pulling full availability data
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Namegrep have an official developer API?+
What does each object in the domains array actually contain?+
domains array from search_domains includes the domain label (the second-level name, without TLD) and five boolean fields — one per supported TLD (.com, .net, .org, .co, .io) — indicating whether that TLD is currently available for registration.What happens if my regex matches more than 50,000 labels?+
search_domains endpoint returns only 50,000 results maximum; if your pattern exceeds that, the response still includes the full count but the domains array is truncated. Running count_combinations first lets you verify the match volume and refine the pattern to stay within the limit.