# Name Clearance Verdict — Trademark & Domain Check (`shane_reich/name-clearance-verdict`) Actor

One call: is this brand name safe to use? Trademark knockout across USPTO + TMview (70+ IP offices) with phonetic collision matching, domain availability, best-effort social handles, a composite risk grade, and alternative names that clear. Built for AI agents via MCP. Not legal advice.

- **URL**: https://apify.com/shane\_reich/name-clearance-verdict.md
- **Developed by:** [Shane Reich](https://apify.com/shane_reich) (community)
- **Categories:** MCP servers, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 clearance verdicts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Brand Name Clearance — is this name safe to use?

One call answers what every founder and AI agent asks before committing
to a name: **can I actually use it?**

Send a name + one-line product description. Get one structured verdict
from official public sources:

- **Trademark knockout**: USPTO + TMview (EUIPO's aggregation of 70+
  IP offices) — live/pending marks only
- **Phonetic & fuzzy matching** — catches *Kwik/Quick*, *Lyft/Lift*
  conflicts, not just exact hits
- **Nice-class inference** from your description
- **Domains** via RDAP (com, io, co, ai, app, dev)
- **Handles** (GitHub, X, Instagram) — best-effort, labeled
- **One grade**: CLEAR / CAUTION / HIGH\_RISK / UNKNOWN
- **Alternatives that clear** the same knockout

### Pricing

**$0.10 per completed verdict** ($100 / 1,000). That's the whole model:
no subscription, no minimum, no tiers.

**What is never charged:** runs where a trademark source failed, errors,
and partial results. You pay for verdicts, not apologies. For comparison,
a single manual knockout search — USPTO, then TMview, then domains, then
handles — takes a person about an hour.

### Agent-first (MCP)

Call it mid-conversation from Claude, ChatGPT, Cursor, n8n, Make, or
any MCP client. Deterministic JSON out.

Listed in the [official MCP registry](https://registry.modelcontextprotocol.io)
as `io.github.sreichsbb-stack/reich-tools`. Add to any MCP client:

```json
{
  "mcpServers": {
    "reich-tools": {
      "url": "https://mcp.apify.com?tools=shane_reich/name-clearance-verdict,shane_reich/stock-edge-signals"
    }
  }
}
```

### Example

`{"name": "Zephyrion", "description": "AI fitness app"}` →
`HIGH_RISK — live mark 'ZEPHYRION' — identical`

Real result: "Zephyrion" looks free but carries a registered EU mark
(class 9) and a live US filing (class 20). Exactly the collision this
catches before it costs you.

### Honesty

- A grade is **never** CLEAR if a trademark source failed — partial
  searches say so, loudly.
- Handle checks are best-effort and labeled.
- This is a **knockout search**, not legal advice. Identical names can
  coexist across unrelated classes; near misses can be fatal in related
  ones. Final calls belong with IP counsel.

### Watch mode — keep watching a name you cleared

A verdict tells you the name is safe today. Watch mode tells you when that
changes.

Run the Actor with `mode: "watch"` and it re-runs the same trademark screen
(USPTO + TMview, 70+ offices) for that name and alerts ONLY on new confusable
filings since your last watch run:

```json
{ "mode": "watch", "name": "Zephyrion", "description": "AI fitness app" }
```

- First run: `BASELINE_CREATED` — snapshots every confusable mark on record.
- Later runs: `NO_NEW_FILINGS`, or `NEW_FILINGS_FOUND` with the new marks
  (office, application number, status, Nice classes, and `oppositionPeriodEnd`
  when the registry provides it — the date that matters: oppose early instead
  of litigating later).
- If a trademark source fails mid-check: `WATCH_INCONCLUSIVE` — you are not
  charged and the baseline is untouched. A watch that silently misses filings
  during an outage is worse than no watch; this one refuses to.

Pricing: one `watch-check` event ($0.04) per completed watch run. Errors and
inconclusive checks are never charged.

**Set-and-forget in 2 minutes (no code):**

1. Open the Actor, set the watch input above, and **Save as a task**.
2. **Schedules** → create a schedule (weekly suits most marks) → point it at
   the task.
3. On the task, add an **integration** (email, Slack, or webhook) on finished
   runs — each run's dataset record carries `watchStatus` and `newFilings`.

Watching several names? One task per name — each keeps its own baseline.
AI agents: call the same input on your own cadence via MCP or x402; watch
state persists in your account between runs.

### Agentic payments (x402)

AI agents can run this Actor autonomously — no Apify account or API key required.
Pay per verdict in USDC via the x402 protocol using a prepaid token from
`https://agi.apify.com/protocols/x402/prepaid-tokens`.

Two events: `verdict` at $0.10 per clearance and `watch-check` at $0.04 per watch run. Errors and UNKNOWN / inconclusive results are never charged.

```
curl -s -X POST \
  -H "Authorization: Bearer $PREPAID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "Zephyrion", "description": "AI fitness app", "check_alternatives": true}' \
  "https://api.apify.com/v2/actors/shane_reich~name-clearance-verdict/run-sync-get-dataset-items"
```

### Why

I built this after watching people fall in love with names that were
already taken — and only finding out after the logo, the domain hunt,
and the printing. Five seconds of checking beats months of rebranding.
It's maintained, honest about its limits, and if it breaks I fix it.
Tell me which office or TLD you need next.

***

*Part of the Reich "tools that tell you the truth" line — see also
[Stock Edge Signals](https://apify.com/shane_reich/stock-edge-signals).*

# Actor input Schema

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

verdict = one-off clearance of the name (charges one 'verdict' event). watch = re-run the same trademark screen for a name you've checked before and alert ONLY on new confusable filings since your last watch run (charges one 'watch-check' event; the first watch run creates the baseline). Inconclusive checks are never charged and never alter the baseline.

## `name` (type: `string`):

The proposed brand/product name, e.g. 'Zephyrion'

## `description` (type: `string`):

One line, e.g. 'AI-powered fitness coaching app'. Used to infer Nice classes so the trademark search targets the right categories.

## `check_alternatives` (type: `boolean`):

If the name scores CAUTION or HIGH\_RISK, also return up to 3 variant names that pass the trademark knockout.

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

Domain endings to check availability for.

## Actor input object example

```json
{
  "mode": "verdict",
  "name": "Zephyrion",
  "description": "AI fitness app",
  "check_alternatives": true,
  "tlds": [
    "com",
    "io",
    "co",
    "ai",
    "app",
    "dev"
  ]
}
```

# Actor output Schema

## `verdicts` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("shane_reich/name-clearance-verdict").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("shane_reich/name-clearance-verdict").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 '{}' |
apify call shane_reich/name-clearance-verdict --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shane_reich/name-clearance-verdict",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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