# Namerific Domain Names Scraper (`crawlerbros/namerific-scraper`) Actor

Scrape Namerific.com - premium and brandable domain marketplace. Browse the full catalog, filter by category or tag, pull short/featured/premium collections, and fetch individual domain detail pages with prices, descriptions, tags and logo images.

- **URL**: https://apify.com/crawlerbros/namerific-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Namerific Domain Names Scraper

Scrape **Namerific.com** — a marketplace for premium, brandable, and short domain names for sale with prices. Browse the full catalog, filter by category or tag, pull the short / featured / premium collections, and look up individual domains for sale with descriptions, tags, and logo images. HTTP-only via public pages. No auth, no proxy required.

### What this actor does

- **Seven modes:** `browseAll`, `byCategory`, `byTag`, `byType`, `byDomain`, `byUrls`, `search`
- **Full catalog:** ~6,500 premium .com listings, paginated (111 pages at ~60 per page)
- **Server-side keyword search** (`mode=search`) — verified live, e.g. `?key=music`
- **31 categories** as dropdown options (Technology, Finance, Health, Travel, …)
- **Curated collections:** all Short Domains (366), Featured Domains (83), and Premium Domains (23)
- **Detail pages:** price, description, tags, categories, logo + 3 showcase images, product ID
- **Filters:** price range, domain-length range, keyword — applied after fetch
- **Empty fields are omitted**

### Data Source

**Replacement actor — original slot was "NameBio" (namebio.com).** The NameBio slot was hard-blocked from Apify cloud egress: every request (including Camoufox + AUTO datacenter proxy) was answered with a Cloudflare "Attention Required!" challenge that never cleared from datacenter IPs. This actor replaces that slot with **Namerific.com**, the same niche (a domain sales database of premium/expired domains with prices).

Namerific is an OpenCart-style site whose pages are fully server-rendered. Verified from Apify-cloud egress with HTTP 200 on every surface this actor uses:

| Surface | URL | Verified |
|---|---|---|
| Full catalog (paginated) | `https://www.namerific.com/?page=N` | 200, 111 pages |
| Keyword search | `https://www.namerific.com/?key=music` | 200, 2 results |
| Short domains | `https://www.namerific.com/short-domains` | 200, 366 listings |
| Featured domains | `https://www.namerific.com/featured-domains` | 200, 83 listings |
| Premium domains | `https://www.namerific.com/premium-domains` | 200, 23 listings |
| Detail page | `https://www.namerific.com/vajox` | 200 |

> **Category/tag caveat:** the site's own category/tag browse URLs (`?category=…`, `?tag=…`) are broken — they return a random subset of the catalog instead of matching domains (verified live). `mode=byCategory`/`mode=byTag` therefore walk the catalog and verify each candidate's category/tag on its **detail page** (authoritative source), bounded by `scanLimit`. `mode=search` uses `?key=…`, which the server honors.

Listing cards expose the domain name (`item_name` / `img-icon-name`), the price (`item_price` / `img-icon-price`), a product ID (`data-id` / `data-product_id`), an optional collection badge (premium / featured / short sprite), and the logo image. Detail pages add a description, free-form tags, categories, and showcase images.

The site is not affiliated with this actor — it is a third-party marketplace scraped via its public pages.

### Output per domain

Listing modes (`browseAll`, `byCategory`, `byTag`, `byType`, `search`) emit `recordType: "domainListing"`:

- `domainName` — e.g. `Vajox.com`
- `price` — asking price in USD (integer), e.g. `999`
- `productId` — Namerific product ID, e.g. `37906`
- `listingType` — `short` / `featured` / `premium` when the card carries a badge
- `category` — the category slug when browsing by category (mode=byCategory)
- `tag` — the tag when browsing by tag (mode=byTag)
- `keyword` — the search keyword when using mode=search
- `logoUrl` — logo image, **rehosted in the Apify Key-Value Store** so it loads from any plain HTTP client (the origin serves images only to browser User-Agents); `logoUrlOriginal` keeps the namerific.com source URL
- `domainUrl` — canonical detail page URL
- `sourceUrl`, `scrapedAt`, `recordType`

Detail modes (`byDomain`, `byUrls`) emit `recordType: "domainDetail"`:

- `domainName`, `price`, `productId`, `domainUrl`, `sourceUrl`, `scrapedAt`, `recordType`
- `description` — seller's one-line brand description
- `tags[]` — free-form tags, e.g. `["music", "app", "brand"]`
- `categories[]` — category slugs shown on the detail page
- `logoUrl` — large logo (rehosted; `logoUrlOriginal` = source URL)
- `showcaseImages[]` — 3 marketing showcase images (rehosted; `showcaseImagesOriginal[]` = source URLs)

Lookups that fail (`404`, fetch errors) emit a typed `recordType: "error"` record with the failing URL and a message, so you can see exactly which domains could not be resolved.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browseAll` | `browseAll` / `byCategory` / `byTag` / `byType` / `byDomain` / `byUrls` / `search` |
| `category` | string | – | Category slug (mode=byCategory), 31 options in the dropdown |
| `tag` | string | – | Free-form tag, e.g. `music` (mode=byTag) |
| `searchQuery` | string | `music` | Keyword for the server-side search (mode=search), e.g. `vajox` |
| `listingType` | string | – | `short` / `featured` / `premium` (mode=byType) |
| `domains` | array | `[]` | Domain names or slugs, e.g. `["vajox.com"]` (mode=byDomain) |
| `startUrls` | array | `[]` | Detail page URLs (mode=byUrls) |
| `minPrice` | int | – | Drop listings below this USD price (0–10,000,000) |
| `maxPrice` | int | – | Drop listings above this USD price (0–10,000,000) |
| `minLength` | int | – | Min length of the brandable part (e.g. `vajox` = 5) |
| `maxLength` | int | – | Max length of the brandable part |
| `containsKeyword` | string | – | Only keep domains containing this text (case-insensitive) |
| `maxItems` | int | `50` | Hard cap (1–1000) |
| `scanLimit` | int | `500` | Max detail pages scanned for byCategory/byTag matches (50–5000) |
| `proxyConfiguration` | object | AUTO on | Optional; AUTO datacenter proxy is enough |

#### Example: full catalog with price and length filters

```json
{
  "mode": "browseAll",
  "minPrice": 500,
  "maxPrice": 2000,
  "minLength": 5,
  "maxLength": 8,
  "maxItems": 100
}
```

#### Example: browse one category

```json
{
  "mode": "byCategory",
  "category": "technology",
  "maxItems": 100
}
```

#### Example: short domains with a keyword

```json
{
  "mode": "byType",
  "listingType": "short",
  "containsKeyword": "trip"
}
```

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "music",
  "maxItems": 50
}
```

#### Example: lookup specific domains

```json
{
  "mode": "byDomain",
  "domains": ["vajox.com", "jumpclick.com"]
}
```

### Use cases

- **Domain investing** — monitor premium and brandable domain asking prices by category
- **Startup naming** — find a catchy brandable .com with a ready-made logo by category or tag
- **Keyword research** — pull short / one-word domains by length filters for brand building
- **Market intelligence** — track the short and premium domain collections for pricing trends
- **Lead lists** — export candidate domain names + prices for a niche in CSV/JSON

### FAQ

**What is the data source?** Namerific.com, a marketplace selling premium brandable .com domains with logo designs, scraped through its public server-rendered pages. No account or API key is needed.

**Why did this actor replace NameBio?** NameBio is protected by Cloudflare bot management that blocks every Apify datacenter IP (the challenge never clears), making it impossible to scrape from Apify cloud. Namerific covers the same data category — a domain sales database with prices — and is fully reachable.

**Does search work?** Yes — `mode=search` uses Namerific's `?key=` search parameter, which the server honors (verified: `?key=music` → MusicalExperts.com, MusicInstitutes.com). The old OpenCart `route=product/search` endpoint ignores the query, and Namerific's category/tag browse URLs return unfiltered lists, so `byCategory`/`byTag` verify matches on each domain's detail page instead. `containsKeyword` remains for client-side keyword filtering on any mode.

**How fresh is the data?** Pages are fetched live on every run; each run reflects the current listing state.

**Why are some listing cards missing a price or badge?** Some listings have no price or no collection badge on their card; those fields are simply omitted rather than filled with placeholders.

**Do the image URLs work?** Yes — logo and showcase images are automatically **rehosted into the actor's Key-Value Store** on every run, so the emitted `logoUrl` / `showcaseImages[]` load from any plain HTTP client with no headers. (The origin namerific.com only serves its images to browser User-Agents, returning 403 to plain clients.) The original namerific.com URLs remain available as `logoUrlOriginal` / `showcaseImagesOriginal[]` for traceability.

**Are there rate limits?** Namerific is a small marketplace site. The actor requests pages politely (0.3–0.6 s between pages) and retries with backoff on 429/5xx, so runs stay well within safe volumes.

**Is this actor affiliated with Namerific?** No — this is an independent third-party scraper using the marketplace's public pages.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `category` (type: `string`):

Browse only domains in this category.

## `tag` (type: `string`):

Browse only domains carrying this tag (e.g. `music`, `finance`, `fashion` — tags are free-form on Namerific). Namerific's server-side tag filter is broken, so the actor walks the catalog and verifies tags on each domain's detail page.

## `searchQuery` (type: `string`):

Keyword searched against domain names/descriptions via Namerific's server-side search (`?key=`), e.g. `music`, `vajox`.

## `listingType` (type: `string`):

Pull the full short, featured or premium domain collection.

## `domains` (type: `array`):

Exact domain names or slugs to look up, e.g. `vajox.com` or `vajox`.

## `startUrls` (type: `array`):

Namerific detail page URLs, e.g. `https://www.namerific.com/vajox`.

## `minPrice` (type: `integer`):

Drop listings priced below this. Applied client-side after fetching (the site's server-side price filter is broken).

## `maxPrice` (type: `integer`):

Drop listings priced above this.

## `minLength` (type: `integer`):

Drop domains whose brandable part (before the TLD) is shorter than this, e.g. `vajox` = 5.

## `maxLength` (type: `integer`):

Drop domains whose brandable part (before the TLD) is longer than this.

## `containsKeyword` (type: `string`):

Only emit domains whose name contains this text (case-insensitive). Use this instead of the site's search box — Namerific's server-side search ignores the query.

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

Hard cap on emitted records.

## `scanLimit` (type: `integer`):

Maximum domain detail pages to fetch while hunting for category/tag matches (Namerific filters client-side only). Raise it for rare tags.

## `proxyConfiguration` (type: `object`):

Optional. The free Apify AUTO proxy group is enough; the source works from datacenter IPs without proxy.

## Actor input object example

```json
{
  "mode": "browseAll",
  "searchQuery": "music",
  "domains": [],
  "startUrls": [],
  "maxItems": 50,
  "scanLimit": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `domains` (type: `string`):

Dataset containing all scraped Namerific domain listings.

# 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 = {
    "mode": "browseAll",
    "searchQuery": "music",
    "domains": [],
    "startUrls": [],
    "maxItems": 50,
    "scanLimit": 500,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/namerific-scraper").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 = {
    "mode": "browseAll",
    "searchQuery": "music",
    "domains": [],
    "startUrls": [],
    "maxItems": 50,
    "scanLimit": 500,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/namerific-scraper").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 '{
  "mode": "browseAll",
  "searchQuery": "music",
  "domains": [],
  "startUrls": [],
  "maxItems": 50,
  "scanLimit": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/namerific-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/namerific-scraper"
        }
    }
}

```

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/hjdoq7lc9TZBh91D1/builds/NRZHt3i7oRoyuGc8f/openapi.json