Owning Launches MCP Server — The First Classifieds Marketplace Accessible by AI Agents

Today we're announcing something that hasn't been done in the classifieds space: Owning now has a native MCP server. Any MCP-compatible AI client — Claude Desktop, Cursor, Windsurf, or a custom agent — can search and browse listings on Owning programmatically. No web scraping, no HTML parsing, no reverse-engineered APIs.

This makes Owning the first classifieds marketplace with native MCP (Model Context Protocol) support. In this post, we'll explain what MCP is, why it matters for a marketplace, how to connect in 30 seconds, and what's available today.

What is MCP?

MCP — Model Context Protocol — is an open standard introduced by Anthropic in late 2024. It defines a simple, standardized way for AI agents to interact with external services through a tool interface. Instead of every agent integration being a custom one-off, MCP provides a common protocol: the agent calls tools, the server responds with structured data, and the agent uses that data to answer questions or take actions.

Think of it as USB-C for AI agents. Before USB-C, every device had its own charging cable. Before MCP, every agent-to-service integration was a bespoke API wrapper. MCP standardizes the connection so that any MCP-compatible client can talk to any MCP server out of the box.

The protocol runs over JSON-RPC 2.0 and supports two transports: stdio (for local servers) and Streamable HTTP (for remote servers). Owning uses the Streamable HTTP transport, which means any client that can make HTTP requests can connect — no local installation required.

Why MCP matters for a classifieds marketplace

Every major classifieds marketplace — Craigslist, eBay, Wallapop, Gumtree, Facebook Marketplace — was built for human eyes. The data lives in HTML pages designed for rendering in a browser. If you want an AI agent to search those platforms, you're scraping HTML and hoping the DOM structure doesn't change. It's brittle, fragile, and legally gray.

We built Owning differently. Every listing has structured data from the start — brand, model, condition, price, location, category-specific attributes. The REST API serves JSON natively, and listings are also available in Markdown format. MCP is the natural extension of this philosophy: instead of agents parsing our HTML or constructing REST API calls, they call tools through a standard protocol and get structured data back.

The practical difference is significant. An agent connected to Owning via MCP can:

• Search listings with full-text queries and filters (category, brand, price range, location) — and get clean JSON back, not HTML to parse.
• Read a listing in Markdown — a format that's ideal for LLM context windows. No noise, no navigation elements, just the listing data.
• Discover the category schema — what attributes are available for boats vs. cars vs. electronics — so the agent knows what filters to use and what data to expect.

How to connect from Claude Desktop

Connecting Owning to Claude Desktop takes about 30 seconds. Open your Claude Desktop configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the Owning MCP server:

{
  "mcpServers": {
    "owning": {
      "url": "https://mcp.owning.pro/mcp"
    }
  }
}

Restart Claude Desktop. You should see "owning" in the list of available MCP servers, with 5 tools ready to use.

Connecting from other MCP clients

Any client that supports the MCP Streamable HTTP transport can connect. The endpoints are:

MCP endpoint:   POST https://mcp.owning.pro/mcp
SSE endpoint:   GET  https://mcp.owning.pro/mcp/sse
Health check:   GET  https://mcp.owning.pro/health

You can test the connection with a simple curl — list available tools:

curl -X POST https://mcp.owning.pro/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list"
  }'

Or search for listings directly:

curl -X POST https://mcp.owning.pro/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "search_listings",
      "arguments": {
        "query": "yacht",
        "limit": 5
      }
    }
  }'

The 5 tools available today (Phase A — Read-Only)

1. search_listings

Full-text search across title, description, tags, and attributes. Supports filters: category, brand, min_price, max_price, location, with pagination via limit and offset. Returns matching listings with title, price, condition, location, images, and key attributes as JSON.

2. get_listing

Get full details of a specific listing by its ID or slug. Returns everything: description, specifications, all images, pricing, location, and the complete attribute set as JSON.

3. get_listing_markdown

Get a listing formatted as Markdown — optimized for LLM consumption. This is the tool you'll use most when feeding listing data into an agent's context. The output is clean, structured Markdown with title, price, description, specifications, and image links — no HTML noise.

4. list_categories

List all available categories on Owning with their listing counts. Returns a hierarchical tree of parent and subcategories with slug names. Useful for agents that need to discover what's available before searching.

5. get_asset_type

Get the attribute template for a specific category. This tells an agent what fields and filters a category supports — for example, boats have brand, model, year, length, engine_hours, fuel_type; cars have mileage, transmission, fuel_type. The agent can use this to construct informed searches and understand the data it gets back.

Architecture: a thin wrapper, not a new system

The MCP server is deliberately simple. It's a thin protocol translation layer — it takes MCP requests (JSON-RPC 2.0) and translates them into HTTP calls to the existing Owning REST API at api.owning.pro. No business logic lives in the MCP server.

Claude Desktop / Cursor / any MCP client
  │
  │  MCP protocol (JSON-RPC 2.0 over HTTP)
  ▼
MCP Server (mcp.owning.pro — Hono + Bun)
  │
  │  HTTP calls to api.owning.pro
  ▼
Owning API (api.owning.pro)

We implemented the JSON-RPC protocol directly rather than using the official MCP SDK. The SDK's transports are designed for stateful connections (stdio, persistent SSE), but our server is stateless — each POST is a complete request→response cycle. Direct implementation is simpler, more reliable, and eliminates the SDK as a dependency. The server still fully implements the MCP protocol: initialize, ping, tools/list, tools/call.

The stack is Hono + Bun, consistent with the rest of the Owning services. The server deploys as a self-contained Docker image on Railway, auto-deploying from main.

What's next: Phase B (Write Tools)

Phase A is read-only — search, browse, and read. Phase B adds write tools so agents can do the full lifecycle: create a listing, upload images, publish, update, delete, contact a seller, and mark an item as sold. That's 7 additional tools, pending the completion of our organic listings backend.

When Phase B ships, an agent will be able to do end-to-end: search for an item → evaluate listings → contact a seller → or create and publish a new listing with images — all through MCP, all programmatically.

Get started

• Connect from Claude Desktop — add the config above and restart. Try asking Claude: "Search Owning for used boats under €100,000 in Spain."
• Read the docs — full MCP server documentation with all tool schemas, parameters, and examples is at owning.pro/mcp.
• Browse the source — the MCP server code is open at github.com/supertowers/owning under services/mcp/.
• Already using our API? — Read our Developer API Guide for the full REST API reference, or the API overview for a broader introduction.

We're excited to see what people build with this. If you create something with the Owning MCP server, let us know — we'll feature interesting integrations.