# Vercel Domain Scraper (`crawlerbros/vercel-domain-scraper`) Actor

Check domain-name availability and pricing across TLDs using Vercel's official Registrar API. Generate keyword x TLD combinations, list supported registrar TLDs, get standard/premium/renewal pricing, and surface alternative domains for names that are already taken.

- **URL**: https://apify.com/crawlerbros/vercel-domain-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **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

## Vercel Domain Scraper

Check domain-name availability, supported registrar TLDs, standard/premium/renewal pricing, and cross-TLD alternatives through Vercel's official Registrar API. The actor can check exact domains directly, generate keyword x TLD combinations in bulk, list Vercel-supported TLDs, or price selected TLDs.

### What This Actor Does

- Bulk availability checks using `POST /v1/registrar/domains/availability`
- Exact domain checks via the `domains` input
- Keyword x TLD generation via `keywords` and `tlds`
- Supported TLD listing via `GET /v1/registrar/tlds/supported`
- TLD base pricing via `GET /v1/registrar/tlds/{tld}/price`
- Purchase, renewal, and transfer pricing for available domains when Vercel returns those fields
- Premium-price detection by comparing a domain price against the TLD base price
- Cross-TLD alternatives for taken domains
- Controlled status rows for missing credentials, missing targets, invalid tokens, or no emitted domain rows

### Data Source

This actor calls Vercel's official Registrar REST API at `https://api.vercel.com`. It does not scrape `vercel.com/domains`; that public UI is bot-walled, while the documented API is the reliable supported surface for this data.

The current Vercel OpenAPI schema documents these endpoints and response fields:

- `GET /v1/registrar/tlds/supported` returns a list of supported TLD strings.
- `POST /v1/registrar/domains/availability` returns `{results: [{domain, available}]}`.
- `GET /v1/registrar/tlds/{tld}/price` returns `years`, `purchasePrice`, `renewalPrice`, and `transferPrice`.
- `GET /v1/registrar/domains/{domain}/price` returns pricing fields for available domains; unavailable or inapplicable fields are omitted from actor rows.

### Scope / Limitations

This actor only calls **read-only** Vercel Registrar endpoints (availability, pricing, supported TLDs). Vercel's Registrar API also exposes endpoints to buy a domain, transfer a domain in or out, renew a domain, and change nameservers/auto-renew settings — this actor deliberately does not call any of those. They spend real money or move real domains under your Vercel account, which is out of scope for a data-checking actor and unsafe to wire into a general-purpose tool. If you need those actions, use Vercel's own dashboard, CLI, or API directly with your token.

The actor also skips the `GET /v1/registrar/tlds/{tld}` metadata endpoint (it only returns supported registration-form language codes, not pricing or availability data) — it isn't useful for domain shopping and would add up to one extra API call per TLD checked.

### How to get your Vercel API token

This actor calls Vercel's Registrar API on your behalf, so it needs your own personal access token. Takes under a minute:

1. Sign in to your Vercel account and go to **[vercel.com/account/tokens](https://vercel.com/account/tokens)** (Account Settings → Tokens).
2. Click **Create Token**.
3. Give it a name you'll recognize later, e.g. `apify-domain-scraper`.
4. Under **Scope**, choose:
   - **Your personal account**, if you're checking domains for yourself — leave the actor's `teamId` input empty, or
   - **A specific team**, if the token should act on a Vercel team's behalf — then copy that team's ID (starts with `team_`, found in the team's **Settings** page) into the actor's `teamId` input. A team-scoped token used without the matching `teamId` will fail with an "unauthorized" error.
5. Under **Expiration**, pick a duration that fits how long you'll be running this actor. You can always create a new token later if it expires.
6. Click **Create**, then **copy the token immediately** — Vercel only shows it once. If you navigate away before copying it, you'll need to create a new one.
7. Paste the token into the actor's **Vercel API token** input field. It's marked as a Secret field, so Apify encrypts it and never displays it back in the input or logs.

**A note on token scope:** Vercel doesn't currently offer a token permission narrower than full account access — a token that can check domain availability can also act on the rest of your Vercel account (deployments, projects, etc.). Treat it like any other credential: don't share it, and revoke it from the tokens page above if you no longer need it running.

### Input

| Field | Type | Required by actor | Default | Description |
|---|---|---|---|---|
| `mode` | string | No | `domainCheck` | `domainCheck`, `supportedTlds`, or `tldPricing`. |
| `vercelApiToken` | string (secret) | Yes | none | Your Vercel API token from `vercel.com/account/tokens`. |
| `teamId` | string | No | none | Set this if the token is scoped to a Vercel team. |
| `domains` | array of strings | No | `[]` | Exact apex domains to check directly, such as `example.com` or `https://brand.dev/path`. |
| `keywords` | array of strings | No | `[]` | Base names to combine with TLDs, such as `mystartup`. Use this or `domains`. |
| `tlds` | array of strings | No | curated popular TLDs | TLDs for keyword generation or TLD pricing, with or without the leading dot. Compound TLDs such as `br.com` and punycode TLDs such as `xn--q9jyb4c` are accepted. |
| `maxCombinations` | integer | No | `50` | Hard cap across exact domains plus generated keyword x TLD combinations. In TLD modes, this caps emitted TLD rows. |
| `includePremiumPricing` | boolean | No | `true` | Fetch pricing for available domains and derive `isPremium`. |
| `includeAlternatives` | boolean | No | `true` | Attach available same-keyword alternatives to taken domains. |
| `pricingYears` | integer | No | `1` | Registration term to price, from 1 to 10 years. |

### Examples

Check exact domains:

```json
{
  "mode": "domainCheck",
  "vercelApiToken": "your-vercel-api-token",
  "domains": ["example.com", "example.dev", "mybrand.io"],
  "includePremiumPricing": true
}
```

Check startup names across selected TLDs:

```json
{
  "mode": "domainCheck",
  "vercelApiToken": "your-vercel-api-token",
  "keywords": ["mystartup", "myapp"],
  "tlds": ["com", "io", "dev", "app"],
  "includePremiumPricing": false
}
```

Check a broader generated set:

```json
{
  "mode": "domainCheck",
  "vercelApiToken": "your-vercel-api-token",
  "keywords": ["example", "mystartup"],
  "maxCombinations": 50
}
```

List supported TLDs:

```json
{
  "mode": "supportedTlds",
  "vercelApiToken": "your-vercel-api-token",
  "maxCombinations": 500
}
```

Price selected TLDs:

```json
{
  "mode": "tldPricing",
  "vercelApiToken": "your-vercel-api-token",
  "tlds": ["com", "dev", "app", "br.com"],
  "pricingYears": 1
}
```

### Output

Domain rows use `recordType: "domainCheck"` and include fields when Vercel returns them:

- `domain`
- `keyword`
- `tld`
- `available`
- `purchasePrice`
- `renewalPrice`
- `transferPrice` when Vercel returns it
- `isPremium`
- `alternatives`
- `pricingCurrency` (`USD`) — only present when `includePremiumPricing` is on
- `pricingYears` — only present when `includePremiumPricing` is on
- `scrapedAt`

Supported TLD rows use `recordType: "supportedTld"` and include:

- `tld`
- `supported`
- `sourceEndpoint`
- `scrapedAt`

TLD price rows use `recordType: "tldPrice"` and include:

- `tld`
- `supported`
- `purchasePrice`
- `renewalPrice`
- `transferPrice` when Vercel returns it
- `pricingCurrency` (`USD`)
- `pricingYears`
- `sourceEndpoint`
- `scrapedAt`

Status rows use `recordType: "status"` and include:

- `_status`
- `_reason`
- `_message`
- `scrapedAt`
- optional context fields such as `domain`, `tld`, `apiStatusCode`, or `sourceEndpoint`

### FAQ

**Why does this actor need my own API token?** Vercel's public domain-search UI blocks anonymous automation. Vercel's official Registrar API provides the same domain availability and pricing data through normal Bearer-token authentication. See [How to get your Vercel API token](#how-to-get-your-vercel-api-token) above.

**Is it safe to give this actor my Vercel token?** The actor only ever calls the read-only registrar endpoints listed under [Data Source](#data-source) — it never calls any endpoint that could modify your account, deployments, or projects. Apify stores the token as an encrypted Secret input and it's never logged or echoed back in the output.

**Will the actor return anything without a token?** Yes, it emits a status row explaining that `vercelApiToken` is required, then exits cleanly. It cannot return real domain availability without your Vercel credential.

**Why do taken domains not show pricing?** Taken domains cannot be purchased through the registrar flow, so the actor only fetches pricing for domains that Vercel reports as available.

**What does `isPremium` mean?** The API does not expose a premium flag. The actor derives it by comparing a domain's purchase price against the base price for that TLD at the same registration term.

**Is pricing in USD?** Yes. Vercel registrar pricing is treated as USD, and rows include `pricingCurrency: "USD"`.

# Actor input Schema

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

Choose what to fetch from Vercel Registrar: domain availability checks, supported TLDs, or TLD pricing.

## `vercelApiToken` (type: `string`):

Your personal Vercel API token, created at vercel.com/account/tokens. This actor calls Vercel's own Registrar API on your behalf and cannot return domain data without it.

## `teamId` (type: `string`):

Optional. Set this if your API token is scoped to a Vercel team (starts with `team_`).

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

Optional exact apex domains to check directly, e.g. `example.com`, `brand.dev`, or `https://example.com/path`. These are checked before generated keyword x TLD combinations.

## `keywords` (type: `array`):

Base names to check across TLDs, e.g. `mystartup`. Full URLs or existing domains are also accepted; only the base label is used. Use this or `domains`.

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

TLDs to check or price, with or without the leading dot (e.g. `com`, `.dev`, `br.com`, or `xn--q9jyb4c`). Leave empty to use a curated list of popular TLDs for domain checks and TLD pricing.

## `maxCombinations` (type: `integer`):

Hard cap on exact domains plus keyword x TLD combinations checked. In `supportedTlds` and `tldPricing` modes, this caps emitted TLD rows.

## `includePremiumPricing` (type: `boolean`):

Fetch purchase/renewal/transfer pricing for each available domain, and derive whether it is premium-priced.

## `includeAlternatives` (type: `boolean`):

For taken domains, list available same-keyword domains on other TLDs as alternatives.

## `pricingYears` (type: `integer`):

Number of registration years to price. Only used when `includePremiumPricing` is on.

## Actor input object example

```json
{
  "mode": "domainCheck",
  "teamId": "",
  "domains": [],
  "keywords": [
    "example",
    "mystartup"
  ],
  "tlds": [],
  "maxCombinations": 50,
  "includePremiumPricing": true,
  "includeAlternatives": true,
  "pricingYears": 1
}
```

# Actor output Schema

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

Dataset containing domain checks, supported TLD rows, TLD price rows, and status rows for controlled no-data inputs.

# 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": "domainCheck",
    "teamId": "",
    "domains": [],
    "keywords": [
        "example",
        "mystartup"
    ],
    "tlds": [],
    "maxCombinations": 50,
    "includePremiumPricing": true,
    "includeAlternatives": true,
    "pricingYears": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vercel-domain-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": "domainCheck",
    "teamId": "",
    "domains": [],
    "keywords": [
        "example",
        "mystartup",
    ],
    "tlds": [],
    "maxCombinations": 50,
    "includePremiumPricing": True,
    "includeAlternatives": True,
    "pricingYears": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vercel-domain-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "domainCheck",
  "teamId": "",
  "domains": [],
  "keywords": [
    "example",
    "mystartup"
  ],
  "tlds": [],
  "maxCombinations": 50,
  "includePremiumPricing": true,
  "includeAlternatives": true,
  "pricingYears": 1
}' |
apify call crawlerbros/vercel-domain-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/vercel-domain-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HQfXO3yKFfjuKMMho/builds/ljMkZWOEAyG781Xrc/openapi.json