# Brand & Business Name Generator · Verified Domains, Handles (`agentsgearbox/brand-name-generator`) Actor

Brand, business and startup name generator with a built-in username and domain availability checker: every candidate verified live on domains (with prices), 37 social and developer handles, App Store and Wikipedia. Keep only names free where you need them. First 3 names free each month.

- **URL**: https://apify.com/agentsgearbox/brand-name-generator.md
- **Developed by:** [AgentsGearbox](https://apify.com/agentsgearbox) (community)
- **Categories:** Agents, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 names

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

## Brand & Business Name Generator · verified domains, handles & prices

A brand, business, startup or product name generator with a built-in username and domain availability checker. Describe what you are naming and get back names that are **actually free**: the AI invents candidates, and every single one is checked live against domain registries (with prices), social and developer handles, the Apple App Store, Wikipedia and the dictionary. One row per name with a complete availability map, or only the names that are free where *you* need them. The first 3 names each month are free for every account.

Why a tool and not a chat? Because the model alone cannot check anything. In our tests, 27 names an AI proposed for a restaurant-booking product had **zero** free `.com` domains; they were all real words. Brand Name Generator generates, checks, learns which names were taken, and generates again until it has what you asked for. You pay only for the names it returns.

Built by [agentsgearbox](https://agentsgearbox.com). Questions: support@agentsgearbox.com.

### What you get

One dataset item per name:

```json
{
  "name": "ospitella",
  "source": "generated",
  "round": 1,
  "freeCount": 14,
  "checkedCount": 15,
  "freeOn": ["com", "it", "io", "telegram", "x", "github", "youtube", "substack", "npm", "linkedin", "bluesky", "appstore", "dictionary", "wikipedia"],
  "takenOn": ["tiktok"],
  "unknownOn": [],
  "passesFilter": true,
  "score": 91,
  "pronounceability": 100,
  "length": 9,
  "syllables": 4,
  "freeDomains": [
    { "domain": "ospitella.com", "priceUsd": 11.08 },
    { "domain": "ospitella.io", "priceUsd": 28.12 },
    { "domain": "ospitella.it", "priceUsd": null }
  ],
  "domains": {
    "com": { "status": "free", "method": "rdap", "priceUsd": 11.08, "renewalUsd": 11.08, "url": "https://ospitella.com" },
    "io":  { "status": "free", "method": "whois", "priceUsd": 28.12, "url": "https://ospitella.io" },
    "it":  { "status": "free", "method": "whois", "url": "https://ospitella.it" }
  },
  "handles": {
    "x": { "status": "free", "url": "https://x.com/ospitella" },
    "tiktok": { "status": "taken", "url": "https://www.tiktok.com/@ospitella" },
    "github": { "status": "free", "url": "https://github.com/ospitella" }
  },
  "collisions": {
    "appstore": { "status": "free" },
    "wikipedia": { "status": "free" },
    "dictionary": { "status": "free" }
  }
}
```

Every channel has one of three statuses: `free`, `taken` or `unknown` (the platform did not answer reliably; an unknown status never counts as free). On the collision channels, `taken` means a conflict exists: an app with exactly that name, a Wikipedia article, a dictionary word.

The run ends with one free `summary` item: how many candidates were generated and checked, how many were returned, why the run stopped, and a hint when nothing passed your filter.

### Two ways to use it: generate names, or check your own

**Generate.** Give a `brief` ("a budgeting app for freelancers in Spain, friendly and simple"), pick the TLDs and platforms you care about, and set `requireFreeOn` to the channels a name must be free on. The actor runs rounds of 40 candidates until it has `maxResults` names that pass, feeding the taken names back into the next round so the model drifts away from what is registered.

**Check.** Give your own `names` and leave `brief` empty: this is a bulk username and domain availability checker. Each name comes back with the same availability map across every TLD and platform you selected. Nothing is generated.

#### For AI agents and automations

Without a filter the actor returns **every** checked candidate, including names that are taken everywhere, because a name that is free on `.com` but taken on Instagram is still useful information. If you need names the user can actually register, **set `requireFreeOn`** (for example `["com", "x", "github"]`) or `minFreeChannels`. The default example input ships with `requireFreeOn: ["com"]`. Channel ids are the TLD without the dot for domains (`com`, `io`, `it`) and lowercase platform ids for handles (`x`, `youtube`, `github`, …); `appstore`, `wikipedia` and `dictionary` are the collision checks.

### Example tasks

Ready-made configurations you can open, copy and run as they are:

- [Find brand names for a SaaS that are free on .com, X and GitHub](https://apify.com/agentsgearbox/brand-name-generator/examples/find-brand-names-free-on-com-x-and-github): coined names for a software product, returned only when the .com, the X handle and the GitHub name are all free, with prices and nine more checks.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `brief` | string | – | What you are naming: product, audience, tone. Required unless `names` is given. |
| `names` | string\[] | – | Check-only mode: your own candidates. Every name is returned (or every name passing the filter). |
| `requireFreeOn` | string\[] | `[]` | Return only names free on **all** these channels. Unknown statuses never pass. |
| `minFreeChannels` | integer | `0` | Return only names free on at least this many channels. |
| `maxResults` | integer | `10` | Names to return in generate mode. |
| `tlds` | string\[] | `["com"]` | Domain extensions to check, without the dot. Only real top-level domains (IANA root zone) are checked; `co.uk`-style second-level extensions and unknown strings are ignored and listed in the summary. |
| `platforms` | string\[] | 9 common ones | Handles to check (full list below). |
| `collisions` | boolean | `true` | App Store exact-name match, Wikipedia article, dictionary word. |
| `style` | enum | `mixed` | `mixed`, `coined`, `blends`, `real-words`, `short`. Coined names are far more often free. |
| `languages` | string\[] | `["English"]` | Languages the names must be easy to say in. |
| `minLength` / `maxLength` | integer | `4` / `10` | Letters per name. |
| `mustContain` / `avoid` | string\[] | – | Fragments every name must contain one of / must never contain. |
| `maxCandidates` | integer | `200` | Cap on generated candidates per run (max 500); the run also stops after three rounds without a match. Only returned names are charged. |
| `includePrices` | boolean | `true` | First-year registration price in USD from a public registrar price list. |
| `concurrency` | integer | `12` | Parallel checks. |

### Channels

**Domains.** Any of the 1,200+ extensions with a public registry service (RDAP, the registries' official protocol) are checked authoritatively: `.com`, `.net`, `.org`, `.app`, `.dev`, `.ai`, `.xyz` and most country codes. `.io` and `.it` are checked over WHOIS. Extensions without a public service (`.co` for example) fall back to DNS and are marked `method: "dns"`: reliable for "taken", good but not perfect for "free", because registries may hold a name as reserved or premium. A DNS pre-check skips the registry call for names that are obviously taken, which keeps runs fast.

**Handles, checked without login or proxies.**

| Id | Platform | Id | Platform |
|---|---|---|---|
| `x` | X (Twitter) handle | `github` | GitHub user or organization |
| `youtube` | YouTube @handle | `githubpages` | name.github.io |
| `tiktok` | TikTok @handle | `dockerhub` | Docker Hub user |
| `twitch` | Twitch channel | `npm` | npm package name |
| `snapchat` | Snapchat username | `pypi` | PyPI package name |
| `telegram` | Telegram @username | `crates` | crates.io crate |
| `bluesky` | Bluesky handle (name.bsky.social) | `rubygems` | RubyGems gem |
| `mastodon` | mastodon.social account | `packagist` | Packagist vendor |
| `linkedin` | LinkedIn company page slug | `netlify` | name.netlify.app |
| `vimeo`, `dribbble`, `soundcloud`, `flickr`, `giphy` | creator profiles | `huggingface` | Hugging Face user or org |
| `strava`, `goodreads`, `steam`, `hackernews`, `kick` | communities | `devto` | DEV Community user |
| `gumroad`, `buymeacoffee`, `aboutme` | creator pages | `slack` | name.slack.com workspace |
| `substack`, `blogger` | name.substack.com, name.blogspot.com | `shopify` | name.myshopify.com |

**Collisions.** `appstore` (an iOS app with exactly this name exists), `wikipedia` (an English Wikipedia article has this title; the detail tells you what it is), `dictionary` (the word has an English Wiktionary entry).

Not available yet: Instagram, Reddit, Medium, Product Hunt, Patreon, Etsy and Threads block datacenter traffic or need a login. They are planned as an opt-in with proxies. Tell us which one you need at support@agentsgearbox.com.

### Pricing

**Try it free.** The first 3 names each calendar month are free for every Apify account, with nothing to enter: the actor keeps count in a small key-value store in your account (`free-slice-brand-name-generator`) and charges only from the 4th on. The free results are real results you keep; the counter resets on the first of each month.

Pay per event, no subscription. The only paid event is a **returned name**: **$0.003** per row. Generation rounds, DNS, registry, handle and collision checks, filtered-out candidates and the summary are free. Apify plans above Free get an automatic discount on every event (10% to 40%).

| Run | Candidates checked | Returned | Cost |
|---|---|---|---|
| 10 names free on `.com`, 3 TLDs and 9 platforms | ~60 | 10 | **$0.03** |
| 25 names free on `.com`, `x` and `github` | ~300 | 25 | **$0.08** |
| Check 100 of your own names across 5 TLDs and 15 platforms | 100 | 100 | **$0.30** |
| 10 names, no filter (full map for every candidate) | 10 | 10 | **$0.03** |

A run that returns nothing costs nothing. Typical run time is 15 to 90 seconds. Apify's free plan includes $5 of monthly usage, which is more than 1,500 returned names.

### Code

**Node.js**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('agentsgearbox/brand-name-generator').call({
    brief: 'A budgeting app for freelancers in Spain. Friendly, simple, trustworthy.',
    requireFreeOn: ['com', 'x', 'github'],
    maxResults: 10,
    tlds: ['com', 'es', 'app'],
    platforms: ['x', 'github', 'youtube', 'tiktok', 'telegram', 'npm'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const n of items.filter((i) => i.type !== 'summary')) console.log(n.name, n.freeDomains.map((d) => d.domain), 'taken on', n.takenOn);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient(token=os.environ["APIFY_TOKEN"])
run = client.actor("agentsgearbox/brand-name-generator").call(run_input={
    "names": ["lumora", "tabellu", "ospitella"],   # check-only mode
    "tlds": ["com", "io"],
    "platforms": ["x", "github", "youtube", "telegram"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") != "summary":
        print(item["name"], item["freeCount"], "/", item["checkedCount"], "free:", item["freeOn"])
```

**cURL**

```bash
curl -s -X POST "https://api.apify.com/v2/acts/agentsgearbox~brand-name-generator/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"brief":"A newsletter about Italian cooking for busy parents","requireFreeOn":["com","substack"],"maxResults":5,"tlds":["com","it"],"platforms":["substack","x","youtube"]}'
```

### Call it from an AI agent

Give your agent hands. Instead of fetching pages, getting blocked and reasoning over HTML, it calls this actor as a tool and gets verified results back as JSON, priced per result. Checking whether 120 candidate names are free means 120 page fetches and a few hundred thousand tokens, and most platforms block an agent anyway. This actor does it in about 40 seconds for $0.03 per ten verified names.

- **MCP, this actor only:** add `https://mcp.apify.com?tools=agentsgearbox/brand-name-generator` to Claude Desktop, Claude Code, Cursor or any MCP client (with your Apify token), then ask for "ten names for my budgeting app that are free on .com, X and GitHub".

* **MCP, all agentsgearbox actors:** `https://mcp.apify.com?tools=agentsgearbox/telegram-channel-scraper,agentsgearbox/google-play-reviews-scraper,agentsgearbox/substack-scraper,agentsgearbox/google-news-scraper,agentsgearbox/brand-name-generator,agentsgearbox/ai-readiness-audit,agentsgearbox/company-lookup,agentsgearbox/app-intelligence,agentsgearbox/app-store-reviews-scraper`

- **No Apify account?** This actor is eligible for Apify's agentic payments: an agent can buy a spend-capped token through [agi.apify.com](https://agi.apify.com) (x402, MPP or Skyfire) and call the API directly.
- Prices are per result and known in advance, so the agent can set a spending limit; error records come back as data instead of failed runs.

When calling it from an agent, pass `requireFreeOn` whenever the user needs registrable names; read `freeOn`, `takenOn` and `freeDomains` from each row and `hint` from the summary.

### Reading the results

- `score` (0–100) blends pronounceability (40%), length (25%) and the share of free channels (35%). It is a sorting aid, not a judgment.
- `pronounceability` penalises consonant clusters, odd vowel ratios and awkward endings. `syllables` is an estimate.
- `method` on a domain tells you how the verdict was reached: `rdap` and `whois` are authoritative, `dns` is an inference.
- `unknownOn` lists channels that did not answer reliably. The summary's `channelsWithMostlyUnknownResults` flags a platform that throttled the whole run; lower `concurrency` or drop it from `platforms`.
- A free domain can still be a registry **premium** name with a higher price. Names shorter than five letters and dictionary words are the usual suspects; the price shown is the standard registration price.

### Troubleshooting

| Symptom | Cause | Fix |
|---|---|---|
| `requireFreeOn contains channels that are not being checked` | A filter id is not in `tlds`/`platforms`, or `collisions` is off | Add the channel to the checked lists or use a valid id from the error message |
| Summary says `EMPTY` or `stoppedBy: "noMatches"` | Nothing passed the filter in three consecutive rounds, so the run stopped early | Fewer channels in `requireFreeOn`, `minFreeChannels` instead, `style: "coined"`, longer `maxLength` |
| Many `unknown` on one platform | Platform throttled our requests | Lower `concurrency`; the next run usually recovers |
| `name not allowed on this platform` | The name breaks that platform's rules (length, characters) | Expected; it is reported as `unknown`, never as free |
| Generated names look Italian/Spanish | `languages` steers the sound | Set `languages: ["English"]` only |

### Limits and honesty

- Verified channels can change their anti-bot rules; when one does, its status becomes `unknown` rather than wrong, and we update the check.
- Trademarks are not checked. The Wikipedia and App Store collisions catch the obvious conflicts; run a trademark search (EUIPO, USPTO) before you commit to a name.
- Handles are checked against public profile endpoints, so very new accounts may take a few minutes to appear.
- Check-only mode handles up to 500 names per run.

### More from agentsgearbox

- [Telegram Channel Scraper](https://apify.com/agentsgearbox/telegram-channel-scraper): public Telegram channels as JSON, no API key.
- [Google Play Reviews Scraper](https://apify.com/agentsgearbox/google-play-reviews-scraper): Google Play reviews with replies and versions, any market.
- [Substack Scraper](https://apify.com/agentsgearbox/substack-scraper): Substack posts with full text and comments, custom domains too.
- [Google News Scraper](https://apify.com/agentsgearbox/google-news-scraper): Google News with real publisher URLs and full text.
- [AI Readiness Audit](https://apify.com/agentsgearbox/ai-readiness-audit): how well AI search engines and agents can read a site: crawler access, llms.txt, structured data, content without JavaScript, scored with fixes.
- [Company Lookup](https://apify.com/agentsgearbox/company-lookup): one row per domain with legal identity and VAT validation, contacts, socials, tech stack, open jobs, apps, news and Wikidata facts.
- [App Intelligence](https://apify.com/agentsgearbox/app-intelligence): App Store and Google Play in one run: search, top charts, full app details and each app's twin on the other store.
- [App Store Reviews Scraper · iOS + Google Play, Any Country](https://apify.com/agentsgearbox/app-store-reviews-scraper): Reviews of any iOS or Android app from both stores in one run: stars, text, version, votes, developer replies, since-last-run checkpoint, rating trend per app..

All of them are pay-per-event, run without a browser, and are compared with their alternatives on [agentsgearbox.com](https://agentsgearbox.com/actors/).

### Support

Email support@agentsgearbox.com or use the issues tab. Compare this actor with alternatives on [agentsgearbox.com](https://agentsgearbox.com).

# Actor input Schema

## `brief` (type: `string`):

Describe the product, company or project: what it does, who it is for, the tone you want. The AI invents candidate names from this and every candidate is verified live. Leave empty if you only want to check your own names (see Names to check).

## `names` (type: `array`):

Your own candidate names. When given, nothing is generated: each name is checked across the selected domains, platforms and collision sources and returned with its availability map.

## `requireFreeOn` (type: `array`):

Channel ids a name must be FREE on to be returned, e.g. \["com", "x", "github"]. Use TLDs for domains (com, io, it) and platform ids for handles (x, youtube, github, …). Without this filter every checked candidate is returned with its full availability map, including names that are taken everywhere. AI agents: set this filter when you need names the user can actually register; the generator keeps producing candidates until it has maxResults names that pass. An unknown status never passes the filter.

## `minFreeChannels` (type: `integer`):

Softer alternative to requireFreeOn: return names free on at least this many of the checked channels (domains + platforms + collision sources). 0 disables it. Combined with requireFreeOn, both must hold.

## `maxResults` (type: `integer`):

Stop after this many names were returned (that is, passed the filter when one is set).

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

TLDs to check for every candidate, without the dot. 1,200+ extensions are supported through the registries' RDAP service; .io and .it use WHOIS; extensions without a public registry service fall back to DNS (status marked with method "dns"). Registration prices are attached when available.

## `platforms` (type: `array`):

Social, creator and developer platforms whose handle or namespace is checked for every candidate. All of these are checked without a login or proxy. Instagram, Reddit, Medium and Product Hunt need proxies and are not available yet.

## `collisions` (type: `boolean`):

Also check whether an app with exactly this name exists on the Apple App Store (channel id appstore), whether the name has an English Wikipedia article (wikipedia) and whether it is an English dictionary word (dictionary). These are collision checks: "taken" means a conflict exists.

## `style` (type: `string`):

What kind of names the AI should invent. Coined and blended names are far more likely to be free than real words.

## `languages` (type: `array`):

Languages the names must be easy to pronounce in. Names are always ASCII letters only.

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

Shortest accepted name (letters).

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

Longest accepted name (letters).

## `mustContain` (type: `array`):

Optional fragments; every generated name contains at least one of them (e.g. \["tab", "book"]).

## `avoid` (type: `array`):

Fragments or words the names must not contain (e.g. competitor names).

## `maxCandidates` (type: `integer`):

Safety cap on how many names the AI may invent and check in one run while looking for names that pass the filter (rounds of 40). The run also stops early after three rounds without a single match. Only returned names are charged.

## `includePrices` (type: `boolean`):

Adds the first-year registration price (USD, from a public registrar price list) to every free domain.

## `concurrency` (type: `integer`):

How many checks run at the same time. Lower it if a platform starts returning unknown statuses.

## Actor input object example

```json
{
  "brief": "A SaaS that lets small restaurants manage online reservations and no-shows with automatic SMS reminders. Audience: independent restaurant owners in Europe. Tone: warm, modern, trustworthy.",
  "requireFreeOn": [
    "com"
  ],
  "minFreeChannels": 0,
  "maxResults": 10,
  "tlds": [
    "com",
    "io",
    "ai"
  ],
  "platforms": [
    "x",
    "youtube",
    "tiktok",
    "telegram",
    "github",
    "linkedin",
    "bluesky",
    "substack",
    "npm"
  ],
  "collisions": true,
  "style": "mixed",
  "languages": [
    "English",
    "Italian"
  ],
  "minLength": 4,
  "maxLength": 10,
  "maxCandidates": 200,
  "includePrices": true,
  "concurrency": 12
}
```

# Actor output Schema

## `results` (type: `string`):

One item per name with its availability map (domains, handles, collisions), plus one free summary item.

# 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 = {
    "brief": "A SaaS that lets small restaurants manage online reservations and no-shows with automatic SMS reminders. Audience: independent restaurant owners in Europe. Tone: warm, modern, trustworthy.",
    "requireFreeOn": [
        "com"
    ],
    "tlds": [
        "com",
        "io",
        "ai"
    ],
    "platforms": [
        "x",
        "youtube",
        "tiktok",
        "telegram",
        "github",
        "linkedin",
        "bluesky",
        "substack",
        "npm"
    ],
    "languages": [
        "English",
        "Italian"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentsgearbox/brand-name-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 = {
    "brief": "A SaaS that lets small restaurants manage online reservations and no-shows with automatic SMS reminders. Audience: independent restaurant owners in Europe. Tone: warm, modern, trustworthy.",
    "requireFreeOn": ["com"],
    "tlds": [
        "com",
        "io",
        "ai",
    ],
    "platforms": [
        "x",
        "youtube",
        "tiktok",
        "telegram",
        "github",
        "linkedin",
        "bluesky",
        "substack",
        "npm",
    ],
    "languages": [
        "English",
        "Italian",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("agentsgearbox/brand-name-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 '{
  "brief": "A SaaS that lets small restaurants manage online reservations and no-shows with automatic SMS reminders. Audience: independent restaurant owners in Europe. Tone: warm, modern, trustworthy.",
  "requireFreeOn": [
    "com"
  ],
  "tlds": [
    "com",
    "io",
    "ai"
  ],
  "platforms": [
    "x",
    "youtube",
    "tiktok",
    "telegram",
    "github",
    "linkedin",
    "bluesky",
    "substack",
    "npm"
  ],
  "languages": [
    "English",
    "Italian"
  ]
}' |
apify call agentsgearbox/brand-name-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agentsgearbox/brand-name-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/6bLVRAw4QzSbul6wJ/builds/4uDit70hw7Z22OUwf/openapi.json