Trademark Clearance & Screening

You are preparing to launch a new brand called “Vyntra” for a line of cloud security software. Before investing in branding and legal filings, you need to determine whether the name is available across your target markets (US, EU, and Canada) in Nice classes 9 and 42. This guide walks through a first-pass clearance workflow using the Signa API, from initial search to conflict analysis. It is a search-based screen of registered and pending marks, not a substitute for a clearance opinion from trademark counsel. For a scored conflict check of a proposed mark against its goods and services, also run it through screening.

Prerequisites

A Signa API key with trademarks:read scope
Your target brand name, jurisdictions, and Nice classes

Run a knockout search

Start with a fast knockout. It runs q through the identical, fuzzy, and embedded channels, which is what Presets.knockout holds in the SDK. It catches the same name after folding case and punctuation, spelling edits like “Vintra”, and marks that contain the term, like “VYNTRA CLOUD”.

curl -G "https://api.signa.so/v1/trademarks" \
  -H "Authorization: Bearer $SIGNA_API_KEY" \
  --data-urlencode "q=Vyntra" \
  --data-urlencode "similarity=identical,fuzzy,embedded" \
  --data-urlencode "jurisdictions=US,EU,CA" \
  --data-urlencode "nice_classes=9,42" \
  --data-urlencode "limit=20"

import { Signa, Presets } from "@signa-so/sdk";

const signa = new Signa({ api_key: process.env.SIGNA_API_KEY });

const knockout = await signa.trademarks.list({
  q: "Vyntra",
  ...Presets.knockout,
  jurisdictions: ["US", "EU", "CA"],
  nice_classes: [9, 42],
  limit: 20,
});

for (const tm of knockout.data) {
  console.log(tm.mark_text, tm.office_code, tm.match?.tier, tm.match?.via);
}

An identical or near_identical hit on a live mark in your classes is often enough to drop the name. If the knockout is clean, run the full search.

Run a full similarity search across jurisdictions

The full search adds the phonetic and lookalike channels, which is what Presets.clearance holds. Phonetic matching catches sound-alikes that spelling edits miss, for example “Wyntra”. Lookalike matching catches character substitutions, such as a zero for an O or a Cyrillic letter that looks Latin.

curl -X POST https://api.signa.so/v1/trademarks \
  -H "Authorization: Bearer $SIGNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Vyntra",
    "similarity": ["identical", "fuzzy", "embedded", "phonetic", "lookalike"],
    "filters": {
      "jurisdictions": ["US", "EU", "CA"],
      "nice_classes": [9, 42],
      "status_stage": ["filed", "examining", "published", "registered", "opposition_period"]
    },
    "options": {
      "aggregations": ["status_stage", "jurisdiction_code", "nice_classes"]
    },
    "limit": 50
  }'

const results = await signa.trademarks.search({
  q: "Vyntra",
  ...Presets.clearance,
  filters: {
    jurisdictions: ["US", "EU", "CA"],
    nice_classes: [9, 42],
    status_stage: ["filed", "examining", "published", "registered", "opposition_period"],
  },
  options: {
    aggregations: ["status_stage", "jurisdiction_code", "nice_classes"],
  },
  limit: 50,
});

console.log(`Matches on this page: ${results.data.length}`);
console.log("Aggregations:", results.aggregations);

Expected output:

{
  "object": "list",
  "data": [
    {
      "id": "tm_a1b2c3d4",
      "mark_text": "VENTRA",
      "status": { "primary": "active", "stage": "registered" },
      "office_code": "US",
      "classifications": [
        { "nice_class": 9, "goods_services_text": "Computer software for payment processing and transit fare collection" },
        { "nice_class": 42, "goods_services_text": "Software as a service (SaaS) featuring payment processing software" }
      ],
      "owners": [
        { "id": "own_xyz789", "name": "Cubic Transportation Systems Inc.", "country_code": "US" }
      ],
      "relevance_score": 88,
      "match": {
        "tier": "near_identical",
        "via": ["fuzzy", "phonetic"],
        "terms": []
      }
    }
  ],
  "aggregations": {
    "status_stage": { "registered": 6, "examining": 4, "published": 2, "filed": 2 },
    "jurisdiction_code": { "US": 8, "EU": 4, "CA": 2 },
    "nice_classes": { "9": 10, "42": 7, "35": 3 }
  },
  "search_meta": {
    "search_id": "srch_9mKp2vLx",
    "query": "Vyntra",
    "similarity_applied": ["identical", "fuzzy", "embedded", "phonetic", "lookalike"],
    "ranking_version": "v12",
    "order": "relevance",
    "complete": true,
    "international_registrations": "expanded",
    "warnings": [
      {
        "code": "expanded_fallback",
        "severity": "info",
        "message": "expanded_fallback: the grouped view cannot serve the aggregations option, so results are one row per record (international_registrations=expanded).",
        "affected_option": "aggregations"
      }
    ],
    "execution_time_ms": 87
  },
  "has_more": true,
  "pagination": { "cursor": "eyJpZCI6..." },
  "request_id": "req_8kLm2nPq"
}

Use jurisdictions (where a right protects), not offices (which register a record came from), for clearance. jurisdictions=EU covers EU trade marks and IRs designating the EU, and jurisdictions=CA covers IRs designating Canada as well as CIPO filings. Requesting aggregations serves the search one row per record (expanded), so the counts above count records, not marks, and search_meta.warnings[] says so. Without aggregations, jurisdictions with nice_classes returns one row per mark. See Filters and grouped results.

Clearing the Benelux takes two codes. jurisdictions=NL matches everything that protects the Netherlands, including EU trade marks and Benelux rights. jurisdictions=BX matches Benelux rights only and leaves out EU trade marks, even though a EUTM protects the Benelux. Request ["BX", "EU"] together, or run the name through Screening, which adds the overlapping regions and reports coverage per region.

match tells you why each result matched. match.tier is the closest similarity category the hit reached: identical, near_identical, similar, or related. match.via lists the channels that found it. VENTRA above is one letter away from VYNTRA and sounds alike, so it arrives as near_identical via fuzzy and phonetic. See Match tiers.

relevance_score (0 to 100) orders the results. It is not a likelihood of confusion. Use match.tier, the classes, and the status to judge risk. See Response.

Exclude your client's own marks

When you clear a name for a client that already holds marks, remove them from the results. entity_id_not drops every mark whose owner is linked to that entity. Exclusions narrow the results and never change the ranking.

curl -G "https://api.signa.so/v1/trademarks" \
  -H "Authorization: Bearer $SIGNA_API_KEY" \
  --data-urlencode "q=Vyntra" \
  --data-urlencode "similarity=identical,fuzzy,embedded,phonetic,lookalike" \
  --data-urlencode "jurisdictions=US,EU,CA" \
  --data-urlencode "nice_classes=9,42" \
  --data-urlencode "entity_id_not=ent_4mRt8vQa"

const others = await signa.trademarks.list({
  q: "Vyntra",
  ...Presets.clearance,
  jurisdictions: ["US", "EU", "CA"],
  nice_classes: [9, 42],
  entity_id_not: ["ent_4mRt8vQa"],
});

owner_id_not excludes single owner records, entity_group_not excludes a whole corporate family, and trademark_ids_not excludes specific marks. On POST, send them under exclude ("exclude": { "entity_id": ["ent_4mRt8vQa"] }). See Exclusions.

Check the spelling variants you plan to file

If the brand team has shortlisted variants, check each one’s exact text with the mark_text_is filter. On GET, repeat the key once per value. Values are never split on commas, because commas are legal in marks. mark_text_is ignores case, accents, punctuation, spacing, and trademark notices, so VYNTRA also matches “Vyntra™”.

curl -G "https://api.signa.so/v1/trademarks" \
  -H "Authorization: Bearer $SIGNA_API_KEY" \
  --data-urlencode "mark_text_is=VYNTRA" \
  --data-urlencode "mark_text_is=VYNTRA CLOUD" \
  --data-urlencode "mark_text_is=VYNTRA SECURE" \
  --data-urlencode "nice_classes=9,42"

const variants = await signa.trademarks.list({
  mark_text_is: ["VYNTRA", "VYNTRA CLOUD", "VYNTRA SECURE"],
  nice_classes: [9, 42],
});

for (const tm of variants.data) {
  console.log(tm.mark_text, tm.office_code, tm.match?.terms);
}

Text filters are deterministic and do not score. Without q, the results come in text order and relevance_score is null. match.terms lists the values each mark satisfied. Combined with q, text filters narrow the ranked results instead. See Text filters.

Triage results by risk level

Use match.tier, match.via, the classes, and the status to categorize matches:

Risk level	Criteria
High	`match.tier` is `identical` or `near_identical` AND same Nice class AND status is live (`status.primary` is `active` or `pending`)
Medium	`match.tier` is `similar`, OR `match.via` includes `phonetic`
Low	`match.tier` is `related`, OR status is dead (`status.primary` is `inactive`)

Filter the full search results to isolate high-risk conflicts:

TypeScript

const targetClasses = new Set([9, 42]);

const conflicts = results.data.filter(
  (tm) =>
    (tm.match?.tier === "identical" || tm.match?.tier === "near_identical") &&
    tm.classifications.some((c) => targetClasses.has(c.nice_class)) &&
    (tm.status.primary === "active" || tm.status.primary === "pending"),
);
console.log(`High-risk conflicts: ${conflicts.length}`);

Pull full details on each conflict

For every high-risk match, fetch the detail tier to see classifications, owners, attorneys, and prosecution history.

# Batch fetch all conflict marks at once (max 100)
curl -X POST https://api.signa.so/v1/trademarks/batch \
  -H "Authorization: Bearer $SIGNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ids": ["tm_a1b2c3d4", "tm_e5f6a7b8", "tm_c9d0e1f2"]
  }'

const details = await signa.trademarks.batch({
  ids: conflicts.map((c) => c.id),
});

for (const tm of details.data) {
  console.log(`${tm.mark_text} (${tm.office_code})`);
  console.log(`  Status: ${tm.status.stage}`);
  console.log(`  Classes: ${tm.classifications.map((c) => c.nice_class).join(", ")}`);
  console.log(`  Owner: ${tm.owners[0]?.name}`);
  console.log(`  G&S: ${tm.classifications[0]?.goods_services_text}`);
}
if (details.not_found.length > 0) {
  console.log("Not found:", details.not_found);
}

Expected output (per mark):

{
  "id": "tm_a1b2c3d4",
  "mark_text": "VENTRA",
  "status": { "primary": "active", "stage": "registered" },
  "office_code": "US",
  "classifications": [
    {
      "nice_class": 9,
      "goods_services_text": "Computer software for payment processing and transit fare collection"
    },
    {
      "nice_class": 42,
      "goods_services_text": "Cloud computing services for payment platforms"
    }
  ],
  "owners": [
    { "id": "own_xyz789", "name": "Cubic Transportation Systems Inc.", "country_code": "US" }
  ],
  "filing_date": "2019-04-12",
  "registration_date": "2020-01-14"
}

Pay close attention to the goods_services_text in each classification. Two marks in the same Nice class can coexist if their goods and services descriptions do not overlap. “Payment processing software” and “cybersecurity software” are both Class 9 but serve different markets.

Review the owner's full portfolio

Understanding the conflicting owner’s portfolio reveals how aggressively they protect their brand and whether they operate in adjacent spaces.

# Get owner profile with stats
curl https://api.signa.so/v1/owners/own_xyz789 \
  -H "Authorization: Bearer $SIGNA_API_KEY"

# List their marks in classes 9 and 42
curl "https://api.signa.so/v1/owners/own_xyz789/trademarks?nice_classes=9,42&limit=50" \
  -H "Authorization: Bearer $SIGNA_API_KEY"

const owner = await signa.owners.retrieve("own_xyz789");

console.log(`Portfolio size: ${owner.stats?.trademark_count}`);
console.log(`Grant rate: ${((owner.stats?.grant_rate ?? 0) * 100).toFixed(0)}%`);
console.log(`Jurisdictions: ${owner.stats?.jurisdiction_count}`);

const ownerMarks = await signa.owners.trademarks("own_xyz789", {
  nice_classes: [9, 42],
  limit: 50,
});
console.log(`Marks in Class 9/42: ${ownerMarks.data.length}`);

Expected output:

{
  "stats": {
    "trademark_count": 142,
    "registered_count": 118,
    "grant_rate": 0.83,
    "jurisdiction_count": 12
  }
}

A high grant_rate (above 80%) and broad jurisdiction coverage suggest an owner with an active legal team. They are more likely to oppose a confusingly similar filing.

Check for proceedings history

See whether the conflicting mark has been involved in oppositions or cancellations. This tells you how actively the owner enforces their rights.

# Check proceedings on the conflicting mark
curl "https://api.signa.so/v1/trademarks/tm_a1b2c3d4/proceedings" \
  -H "Authorization: Bearer $SIGNA_API_KEY"

# Search for opposition proceedings involving the owner
curl "https://api.signa.so/v1/proceedings?q=Cubic+Transportation+Systems&proceeding_type=opposition&limit=20" \
  -H "Authorization: Bearer $SIGNA_API_KEY"

// Check proceedings on the conflicting mark
const proceedings = await signa.trademarks.proceedings("tm_a1b2c3d4");

// Search for opposition proceedings involving the owner
const ownerOppositions = await signa.proceedings.list({
  q: "Cubic Transportation Systems",
  proceeding_type: "opposition",
  limit: 20,
});

console.log(`Mark proceedings: ${proceedings.data.length}`);
console.log(`Owner oppositions filed: ${ownerOppositions.data.length}`);

for (const p of ownerOppositions.data) {
  console.log(`  ${p.proceeding_type} (${p.status}), filed ${p.filed_date}`);
}

Expected output:

{
  "object": "list",
  "data": [
    {
      "id": "prc_op001",
      "proceeding_type": "opposition",
      "status": "decided_granted",
      "parties": [
        { "owner_id": "own_xyz789", "name": "Cubic Transportation Systems Inc.", "role": "opponent" },
        { "owner_id": "own_other", "name": "Ventra Labs LLC", "role": "respondent" }
      ],
      "filed_date": "2023-06-15",
      "decision_date": "2024-02-20"
    }
  ]
}

An owner who has successfully opposed similar marks in the past poses a higher risk. In this example, Cubic already won an opposition against another “Ventra”-variant mark, strong evidence they would oppose “Vyntra” too.

Compile a clearance summary

Bring together all findings into a structured report. Repeat the opposition lookup from the previous step for each distinct conflict owner, then fold the count into the risk assessment:

function assessRisk(input: {
  tier: string | null;
  via: string[];
  sameClass: boolean;
  statusPrimary: string;
  ownerOppositionsFiled: number;
}): "high" | "medium" | "low" {
  const live = input.statusPrimary === "active" || input.statusPrimary === "pending";
  if (!live || input.tier === "related") {
    return "low";
  }
  if ((input.tier === "identical" || input.tier === "near_identical") && input.sameClass) {
    return "high";
  }
  if (input.tier === "similar" || input.via.includes("phonetic") || input.ownerOppositionsFiled > 0) {
    return "medium";
  }
  return "low";
}

// Oppositions filed by each distinct conflict owner
const oppositionsByOwner = new Map<string, number>();
for (const ownerName of new Set(conflicts.map((tm) => tm.owners[0]?.name).filter((n): n is string => Boolean(n)))) {
  const filed = await signa.proceedings.list({ q: ownerName, proceeding_type: "opposition", limit: 20 });
  oppositionsByOwner.set(ownerName, filed.data.length);
}

const assessed = results.data.map((tm) => {
  const ownerName = tm.owners[0]?.name ?? null;
  const ownerOppositionsFiled = oppositionsByOwner.get(ownerName ?? "") ?? 0;
  return {
    trademarkId: tm.id,
    markText: tm.mark_text,
    office: tm.office_code,
    status: tm.status.stage,
    niceClasses: tm.classifications.map((c) => c.nice_class),
    tier: tm.match?.tier ?? null,
    via: tm.match?.via ?? [],
    ownerName,
    ownerOppositionsFiled,
    riskLevel: assessRisk({
      tier: tm.match?.tier ?? null,
      via: tm.match?.via ?? [],
      sameClass: tm.classifications.some((c) => targetClasses.has(c.nice_class)),
      statusPrimary: tm.status.primary,
      ownerOppositionsFiled,
    }),
  };
});

const report = {
  candidateName: "Vyntra",
  targetJurisdictions: ["us", "eu", "ca"],
  targetClasses: [9, 42],
  searchDate: new Date().toISOString(),
  totalConflicts: assessed.filter((c) => c.riskLevel !== "low").length,
  conflicts: assessed,
  recommendation: assessed.some((c) => c.riskLevel === "high")
    ? "HIGH RISK - Consider alternative names"
    : "MODERATE RISK - Proceed with legal counsel review",
};

console.log(JSON.stringify(report, null, 2));

Watch for new conflicts

Rather than re-running this search on a schedule, create a watch scoped to the same query and register a webhook. Signa then evaluates every data update against the watch and pushes an alert the moment a conflicting mark is filed, instead of you polling for one. If you would rather pull results yourself, keep the POST /v1/trademarks body in version control and re-run it on your own schedule, narrowing to filing_date so each call only returns conflicts filed since the last run. filing_date is a leg-level filter, so combined with the other filters it serves the search one row per record (expanded):

TypeScript

const clearanceQuery = {
  q: "Vyntra",
  ...Presets.clearance,
  filters: {
    jurisdictions: ["US", "EU", "CA"],
    nice_classes: [9, 42],
    status_stage: ["filed", "examining", "published", "registered", "opposition_period"],
    filing_date: { gte: lastRunIso },
  },
  limit: 100,
};

const fresh = await signa.trademarks.search(clearanceQuery);
console.log(`New conflicts since ${lastRunIso}: ${fresh.data.length}`);

Persist the timestamp of your last successful run. On the next invocation, pass it as filing_date.gte so the API only returns marks filed since then.

What’s next

Opposition Tracking

Monitor TTAB proceedings if a conflict owner files an opposition against your application.

Competitor Intelligence

Track competing owners to catch new filings in your space before they publish.

Getting started

Core concepts

Build with AI

Data

Monitoring

Working with the API

Use cases

Trademark Clearance & Screening

Prerequisites

Watch for new conflicts

What’s next

Opposition Tracking

Competitor Intelligence

​Prerequisites

​Watch for new conflicts

​What’s next

Opposition Tracking

Competitor Intelligence

Prerequisites

Watch for new conflicts

What’s next