Public Suffix Extractor MCP for AI. Get reliable domain parsing for any URL.

Q: How does Public Suffix Extractor handle .com.br?

It correctly identifies example.com.br as the full domain root. It separates the TLD accurately, recognizing that .com.br is a single registered suffix, not just .br.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Public Suffix Extractor uses the official Mozilla Public Suffix List to parse any URL accurately. It reliably separates hostnames into their true root domain, TLD, and subdomain.

Stop guessing if a domain is `.uk` or `.co.uk`. This tool handles complex structures like `.com.br`, AWS cloud suffixes, and thousands of other global domains with 100% accuracy.

What your AI can do

Extract domain

Takes any hostname and returns the structured Domain, TLD, and Subdomain using the official Mozilla Public Suffix List logic.

Deconstruct Hostnames

The tool breaks down any full hostname into its constituent parts: the true domain root, the TLD, and the subdomain.

Identify Complex TLDs

It accurately determines multi-part country code domains (like .com.br or .co.uk), solving common parsing errors in data pipelines.

Process Cloud Suffixes

The tool correctly handles cloud provider suffixes, identifying them as specific PSL entries rather than assuming they are part of the main domain root.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Public Suffix Extractor MCP Server: 1 Tool for Domain Parsing

Use this single tool to reliably break down any hostname into its core components—the true root domain, the TLD, and the subdomain—using industry-standard rules.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using Public Suffix Extractor on Vinkius

Extract Domain

Takes any hostname and returns the structured Domain, TLD, and Subdomain using the official Mozilla Public Suffix List logic.

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Public Suffix Extractor integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "public-suffix-extractor": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Public Suffix Extractor tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"public-suffix-extractor": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with Public Suffix Extractor, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Public Suffix Extractor MCP server cover

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by psl. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 1 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Parsing URLs used to be guesswork.

Today, when you scrape data or process logs, figuring out a domain's true root is a nightmare. You see `app.vinkius.co.uk` and you have no idea if the TLD is `.uk`, `.co`, or the whole thing. If your code assumes it's just the last segment, your entire data pipeline breaks when it hits a regional site like one ending in `.com.br`.

With this MCP server, that guesswork disappears. You send the full URL to `extract_domain`. The result is clean: the tool spits out the Domain (`vinkius.co.uk`), the TLD (`co.uk`), and the Subdomain (`app`). Your agent gets structured data you can actually trust.

Public Suffix Extractor MCP Server: Get accurate domain parts.

Manual URL processing forces developers to write brittle code full of `if` statements checking for `.co.uk`, then another set for `.com.au`. Every time a new country adds a TLD, your service breaks and needs an urgent patch.

Now you just call the tool. It handles thousands of suffixes based on official Mozilla standards. The domain parsing logic is externalized, stable, and ready to go.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Listen, if your AI agent is dealing with web analytics or any kind of data normalization that involves URLs, you know how messy it gets. You can't just split a hostname by dots and expect to get clean data. That simple trick fails every time you run into country code TLDs (ccTLDs) like .co.uk, because those aren't single segments; they’re two pieces that need treating as one unit.

That's where extract_domain comes in. This tool uses the official Mozilla Public Suffix List logic, which is what major browsers use. It takes any full hostname you throw at it and figures out exactly how it's structured. You don't have to guess if a domain belongs under .uk, or if it’s something more complex like .com.br.

This thing handles that with one hundred percent accuracy.

The function breaks down the entire process into three distinct, reliable parts: deconstructing hostnames, identifying complicated TLD structures, and correctly processing cloud suffixes.

When you run extract_domain on a hostname, it doesn't just give you a mess of strings. It reliably separates the components using PSL logic. First, it breaks down any full hostname into its constituent parts: the true domain root, the TLD, and the subdomain. You get those three pieces separated cleanly.

Think about multi-part country domains. The tool handles them flawlessly. If you feed it a URL that uses .com.br or .co.uk, you don't run into parsing errors in your data pipeline. It accurately determines these complex, multi-segment TLDs, which is huge when you’re dealing with global datasets.

It also handles the cloud provider suffixes correctly. If a hostname uses an AWS suffix or some other cloud platform tag, this tool identifies that specific suffix as a proper PSL entry, instead of assuming it's part of your main domain root—and that difference is everything for clean data.

Using extract_domain lets your agent handle every structure you can imagine, from the simplest domains to complicated regional or cloud setups, no matter how deep the naming convention goes. It always returns the correct segmentation.

If you pass it a full hostname, you'll get three specific outputs:

The Domain: This is the true registrable root domain (for example, if the input was app.vinkius.co.uk, this output gives you vinkius.co.uk).
The TLD: These are the actual Top-Level Domain segments. It pinpoints the entire suffix structure accurately.
The Subdomain: This captures any host information that came before the main domain root (like getting app from app.vinkius.co.uk).

This mechanism ensures your agent doesn't fail when it hits tricky corner cases in real-world data. You just throw a URL at it, and you get structured, clean components back every single time. It’s the definitive way to parse domains because it uses industry-standard rules, not guesswork.

Built · Hosted · Managed by Vinkius Public Suffix Extractor - Parse Domains & TLDs

Server ID 019e38dc-89bc-7093-8b68-f890691a9fce

Vinkius Inspector

Compliance Grade F

Score 3.6/100

Report View Report ↗

Here's how it actually works

The bottom line is: you get reliable, standardized parsing of any URL, regardless of how complex its domain structure is.

Pass a full hostname or URL string to the extract_domain tool.

The server queries its internal model, which uses the Mozilla Public Suffix List logic, to determine domain boundaries and hierarchical structure.

It returns a structured object containing the Domain, TLD, and Subdomain components.

What Changes When You Connect

Stop guessing the TLD. The extract_domain tool uses the official Mozilla Public Suffix List, ensuring you never confuse .uk with .co.uk again. This is critical for accurate data normalization across all regions.

Handle complex domains effortlessly. Whether it's a cloud service like an AWS bucket or a regional site like example.com.br, the tool correctly separates the root domain and TLD components.

It works on any hostname. You don't need to write custom regex for every possible country code or sub-domain structure. Just pass the URL, and it gets parsed into clean parts.

Accuracy over assumptions. Instead of relying on simple string splits that fail instantly with multi-part TLDs, this server processes hostnames using proven browser standards.

Predictable data output. Your agent always receives a consistent object structure: Domain, TLD, and Subdomain. This makes writing downstream processing code much simpler.

See it in action

01 01

Normalizing Web Crawl Data

A web analytics developer gets a list of URLs scraped from various regions (e.g., shop.example.com.br, site.test.co.uk). They ask their agent to run extract_domain on the batch. The tool consistently returns the correct, registrable domains (example.com.br, vinkius.co.uk), allowing the developer's pipeline to group traffic correctly without messy manual cleaning.

02 02

Validating Cloud Endpoints

A backend engineer is building a system that accepts storage bucket endpoints (mybucket.s3.amazonaws.com). They need to know if the full string is valid or what its true components are. The agent uses extract_domain to classify and correctly report the TLD as an AWS cloud suffix, preventing routing errors.

03 03

Building a Domain Hierarchy

A data scientist needs to categorize websites based on their root domain (e.g., distinguishing between google.com and its subdomain mail.google.com). They feed the agent mixed URLs, and extract_domain reliably separates the true root (google.com) from the current operational segment (mail), enabling proper data classification.

04 04

Parsing Redirect Chains

A system tracks user redirects that often involve complex paths like staging.sub-company.globaldomain.net/page. The agent uses extract_domain to extract the clean, registrable domain (globaldomain.net) and its TLD, ignoring temporary or staging subdomains for accurate reporting.

The honest tradeoffs

Using basic regex for URLs

Anti-pattern

Trying to parse app.vinkius.co.uk with a simple pattern that only looks for the last two segments, resulting in incorrect TLD identification (e.g., reporting .uk instead of .co.uk).

The Fix

Use extract_domain. It runs against the official Mozilla Public Suffix List and correctly identifies the full TLD structure (co.uk) while isolating the subdomain (app).

Assuming all dots are separators

Anti-pattern

When encountering a cloud URL like mybucket.s3.amazonaws.com, naive parsing might treat every component as equally important, making it hard to determine the true service domain.

The Fix

Call extract_domain. The tool is designed to handle specific vendor suffixes (like s3.amazonaws.com) correctly, classifying them according to global standards.

Over-relying on client-side parsing

Anti-pattern

Attempting to determine a domain's root structure purely in JavaScript or Python without adhering to established web standards.

The Fix

Use extract_domain within your AI agent. It centralizes the logic, making sure all clients—whether VS Code, Claude, or Cursor—use one single, compliant source of truth for parsing.

When It Fits, When It Doesn't

Use this server if your job requires absolute domain structure accuracy across diverse global domains. If you're building anything that touches analytics logs, redirects, or resource routing based on URLs, you need this.

Don't use it if: 1) You are only validating internal hostnames (e.g., localhost or single-segment names). In those cases, simple string checks might suffice. 2) Your goal is just to extract a specific parameter from the URL path (like an ID after a question mark); for that, a dedicated query parameter extractor tool works better.

This tool specializes in domain parsing, not general URL component extraction. It's about defining the boundaries of the host itself.

Questions you might have

How does Public Suffix Extractor handle .com.br? +

It correctly identifies example.com.br as the full domain root. It separates the TLD accurately, recognizing that .com.br is a single registered suffix, not just .br.

Is Public Suffix Extractor better than regex for domains? +

Yes. Regex struggles with the sheer complexity and variability of global TLDs. This server uses the actual Mozilla Public Suffix List logic, which is a much more robust standard.

What if my domain has an AWS cloud suffix? +

The tool handles this. It will correctly identify components like mybucket.s3.amazonaws.com and classify the TLD portion according to PSL standards, preventing misclassification.

Does Public Suffix Extractor only work on full URLs? +

No. You don't need a full URL. You can pass just the hostname (e.g., app.vinkius.co.uk), and it will still return the structured domain components.

How does the `extract_domain` function handle bare hostnames instead of full URLs? +

It processes bare hostnames just fine. You don't need a protocol or path to use it.
The tool focuses only on the hostname provided, correctly identifying the root domain and TLD without needing the surrounding URL structure.

Are there rate limits when calling `extract_domain`? +

Vinkius manages typical usage rates. If you exceed the defined limit for a given time period, your AI client will receive an appropriate HTTP 429 error.
You'll need to implement back-off logic in your workflow to respect these limits.

Does `extract_domain` use the most current Public Suffix List data? +

Yes, it uses the latest version of Mozilla’s PSL.
We integrate updates regularly, ensuring that domain parsing remains accurate even when new TLDs or cloud suffixes emerge.

Can I process a large list of domains with `extract_domain`? +

The API accepts lists of strings for efficient batch processing. This saves you from making multiple sequential calls.
Just provide an array of hostnames, and the tool will return structured results for each entry.

Why can't I just split the domain by dots? +

Because TLDs like .co.uk, .com.br, and .org.au have multiple parts. Splitting by dots would incorrectly identify the root domain. The PSL has 9,000+ entries.

Does it handle cloud provider domains? +

Yes. Domains like *.amazonaws.com, *.azurewebsites.net, and *.cloudfront.net are in the PSL and handled correctly.

Can I pass a full URL with protocol and path? +

Yes. The engine automatically strips the protocol (http/https), path, and query parameters before parsing.

Connect to your AI in seconds.

Extract domain

Public Suffix Extractor MCP Server: 1 Tool for Domain Parsing

Make your AI actually useful.

Extract Domain

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Parsing URLs used to be guesswork.

Public Suffix Extractor MCP Server: Get accurate domain parts.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Normalizing Web Crawl Data

Validating Cloud Endpoints

Building a Domain Hierarchy

Parsing Redirect Chains

The honest tradeoffs

Using basic regex for URLs

Assuming all dots are separators

Over-relying on client-side parsing

When It Fits, When It Doesn't

Questions you might have