You need to tell a product manager by Friday whether a name is free to trademark and, if not, which classes are still open. By the end of this guide you’ll be able to check trademark availability and pull owner and mark details using a single API key from Zyla API Hub, plug it into your app, CI job, or moderation pipeline, and return actionable results fast.
What this API delivers and when to use it
The Trademark Search API on Zyla API Hub exposes three read endpoints:
- Search: look up owners by name or postcode and retrieve their registered trademarks.
- Trademark Availability: check whether a keyword is available and which Nice classes are available or taken, with related serial numbers.
- TradeMark Search: keyword-driven search that returns core registration metadata (status, owner, filing/registration dates, etc.).
Typical integrations include brand screening before a product launch, marketplace listing moderation, checkout gates for new seller names, and internal audits for conflicts across jurisdictions and classes.
Getting started on Zyla API Hub
Open the API’s marketplace page and subscribe to get your key. Authentication is via Authorization: Bearer YOUR_API_KEY in every request.
- Go to the Start 7-day trial on Trademark Search API page.
- Click Subscribe (or Start Free Trial when available) to obtain an API key.
- Use the same key across any API on Zyla API Hub. Billing is subscription + quota, not pay-per-call. For this first API, you can start with a 7-day trial or 50 requests. Check the API page for current access options and pricing.
Endpoints you’ll call
1) Search
Method: GET
URL: https://zylalabs.com/api/1495/trademark-search-api/1236/search
What it does: Searches by owner name or postcode and returns details about the trademarks found for that owner. Duplicate owners can appear when an owner’s address has changed.
Authentication is required. No request parameters are documented for this example.
cURL (copy-paste):
curl -s -X GET "https://zylalabs.com/api/1495/trademark-search-api/1236/search" \
-H "Authorization: Bearer YOUR_API_KEY"
JSON response (official example):
{
"count": 1,
"items": [
{
"name": "VIAJO.COM INC.",
"address1": "4225 Executive Square, Suite 325",
"address2": null,
"city": "La Jolla",
"state": "CA",
"country": "US",
"postcode": "92037",
"trademarks": [
{
"keyword": "CLICK Y VIAJA",
"registration_number": "2847107",
"serial_number": "75928638"
}
]
}
]
}
What you’ll actually use: count to size your result set; each owner’s name and address fields to confirm identity; and, under trademarks, the keyword plus registration_number and serial_number for downstream checks or UI linking.
2) Trademark Availability
Method: GET
URL: https://zylalabs.com/api/1495/trademark-search-api/1237/trademark-availability
What it does: Returns whether the given keyword is available and lists available_classes, unavailable_classes, and related serial_numbers. Authentication is required. No request parameters are documented for this example.
Use this when you need a yes/no and class breakdown to drive product decisions. For example, a naming service might block submission if unavailable_classes overlaps with the target class set.
3) TradeMark Search
Method: GET
URL: https://zylalabs.com/api/1495/trademark-search-api/1238/trademark-search
What it does: Keyword search that returns mark name, serial and registration numbers, status information, owner details, and filing/registration dates. Authentication is required. The SearchType behavior is described at a high level in the listing, including an “active” type that excludes dead marks; consult the API page for parameter specifics.
Use this for richer detail: status_label/code/definition, filing_date, registration_date, and owners data to build a full profile page or internal dashboard around a candidate mark.
Copy-paste code to ship
Python example: call Search and extract owner and mark IDs
This example calls the Search endpoint, then prints the owner and the first trademark’s serial and registration numbers. It uses the same endpoint as the cURL sample above.
import os
import requests
API_KEY = os.environ.get("ZylaApiKey", "YOUR_API_KEY")
url = "https://zylalabs.com/api/1495/trademark-search-api/1236/search"
headers = {
"Authorization": f"Bearer {API_KEY}",
}
resp = requests.get(url, headers=headers, timeout=30)
resp.raise_for_status()
data = resp.json()
print(f"Total owners: {data.get('count')}")
for owner in data.get("items", []):
print("Owner:", owner.get("name"))
addr = ", ".join(filter(None, [
owner.get("address1"),
owner.get("address2"),
owner.get("city"),
owner.get("state"),
owner.get("postcode"),
owner.get("country"),
]))
print("Address:", addr)
for tm in owner.get("trademarks", []):
print(" - Mark:", tm.get("keyword"))
print(" Registration #:", tm.get("registration_number"))
print(" Serial #:", tm.get("serial_number"))
Implementation notes:
- Auth: always include Authorization: Bearer YOUR_API_KEY.
- Time outs: set a client-side timeout appropriate for your workload.
- Nullables: some address fields may be null; strip them before joining.
- Deduplication: the Search endpoint may return duplicate owners when addresses change; dedupe by a stable key you maintain (e.g., a combination of name + serials you care about).
Practical patterns for availability checks
When you need a go/no-go decision per class, call Trademark Availability and use:
- available: "yes" or "no" for the keyword overall.
- available_classes: list of classes where the mark is still available.
- unavailable_classes: list where conflicts exist.
- serial_numbers: serials tied to conflicting registrations or filings for auditing or UI links.
Typical flow:
- Accept an input keyword from a form or CI variable.
- Call trademark-availability and read available and class arrays.
- If overlap exists between target classes and unavailable_classes, block or warn; otherwise allow reservation and persist a timestamped decision.
- Optionally, follow up with TradeMark Search to gather status and owner information for a dismiss/appeal UI.
Response handling tips that save time
- Response shapes: Search returns a root object with count and items; Trademark Availability returns a list with keyword, available flags, class arrays, and serial_numbers; TradeMark Search returns count and items with detailed fields like status_label and owners.
- Caching: if your UI allows, cache by normalized keyword for short periods to reduce repeated checks in a single session. Invalidate when the user edits the mark.
- Auditing: store serial_numbers from availability checks so that future reviews can reference exactly which filings caused a conflict at the time of decision.
Building production use cases
- Product naming gate: During PRD review, run availability for the candidate name; if available is "no" or target classes intersect with unavailable_classes, require a rename before design commits.
- Marketplace listing moderation: On seller or store creation, validate proposed store name; if conflicts arise, render a denial reason including the first few serial_numbers to demonstrate conflicts.
- Domain-side triage: Combine your domain availability logic with trademark-availability. If a domain is free but the mark is taken in your operating class, block and advise alternatives.
- CI check: In a monorepo, parse a change to branding assets, extract the displayed name, and call availability in a GitHub Action to fail the build if conflicts exist.
Calling the API from AI agents via MCP
If you orchestrate checks from developer tools like Claude Code, Cursor, or Windsurf, you can call the same Hub endpoints through Zyla’s MCP-compatible endpoint. Configure your client to reach the MCP service and supply your API key per your client’s MCP configuration. The agent will invoke the Hub URLs documented above using your Authorization header, so your code and agent workflows stay aligned.
Testing and operational considerations
- Normalization: Normalize keywords (case, accents, punctuation) in your UI and your cache keys so that users don’t get inconsistent answers when toggling case.
- Owner duplicates: Expect duplicates in Search results when historical addresses exist; dedupe in your view layer.
- Latency budgets: Frontend checks should use short client timeouts and optimistic UI patterns; backend batch screening can accommodate longer timeouts.
- Quotas: The Trademark Search API uses subscription + quota, not pay-per-call. Start with the 7-day trial or 50 requests, then adjust your plan as needed on the API page.
Reference: endpoints summary
- Search (GET): https://zylalabs.com/api/1495/trademark-search-api/1236/search
- Trademark Availability (GET): https://zylalabs.com/api/1495/trademark-search-api/1237/trademark-availability
- TradeMark Search (GET): https://zylalabs.com/api/1495/trademark-search-api/1238/trademark-search
All endpoints require an Authorization: Bearer YOUR_API_KEY header. Only the fields and URLs above are documented; if you need additional filters or parameters, check the marketplace page for updates.
FAQ
How do I authenticate?
Include Authorization: Bearer YOUR_API_KEY in every request header to the Hub URLs.
Can I filter by class or jurisdiction in the request?
The public listing above does not document request parameters for these examples. Use the Trademark Availability response’s available_classes and unavailable_classes to decide per-class actions, and check the API’s marketplace page for parameter updates.
What fields tell me a mark is “live” vs “dead”?
Use the TradeMark Search endpoint and read status_label, status_code, and status_definition in the response. The listing notes an “active” SearchType that excludes dead marks; consult the API page for specifics.
Are there duplicate owners?
Yes. The Search endpoint may return duplicate owner entries, especially when the owner has changed addresses. Dedupe downstream based on your business logic.
What’s the pricing model?
Zyla APIs use subscription + quota, not pay-per-call. For this API you can start with a 7-day trial or 50 requests. See the marketplace page for current plans and limits.
Ready to wire this into your app and ship? Get your key and begin with the 7-day trial on the Trademark Search API. One account unlocks thousands of APIs on Zyla API Hub with the same key and subscription model.