# 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/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 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(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 '{}' |
apify call shane_reich/name-clearance-verdict --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shane_reich/name-clearance-verdict"
        }
    }
}
```

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/qwfrefFLBe6pmnFKe/builds/p0bWobLc4mx5J2dc2/openapi.json