Shopping agents need structured product data. Web scraping breaks when retailers redesign their pages, rate-limit bots, or serve different HTML to different user agents. Seekon.me offers an API-first alternative: a unified commerce graph that agents query through the Model Context Protocol (MCP).
This is infrastructure for agentic product discovery. Instead of parsing DOM trees and maintaining brittle XPath selectors, agents call two MCP tools: search_products and get_product_details. The service handles category detection, inventory sync, and merchant link resolution behind a stable interface.
Architecture
Seekon.me exposes a commerce graph through MCP server tools. The flow:
- Agent sends natural language query to
search_products. - Category detection runs internally (algorithm not documented).
- Catalog search returns up to 8 products with images, prices, and merchant data.
- Agent calls
get_product_detailsfor full specs, all images, and all merchant listings.
The MCP server sits between the agent runtime (Claude Desktop, custom orchestrators) and the product database. Authentication happens at the MCP connection level. Connection details are provided through the developer portal after account creation.
MCP Tool Interface
The search_products tool accepts a single query string and returns:
- Identified category
- Matching products (up to 8)
- Non-null properties for each product
- Main image link
- Cheapest merchant name, price, currency, and purchase link
The get_product_details tool accepts either product_id (integer) or unique_id (string) and returns:
- All non-null product fields
- All properties
- All image links
- All merchant listings with purchase links
Both tools return only non-null fields, so agents must handle missing data gracefully.
Query Patterns
The search_products tool collapses three operations into one call:
- Category identification: maps free-text queries to taxonomy nodes.
- Catalog search: returns relevant products.
- Merchant aggregation: returns the cheapest merchant per product.
This reduces latency for conversational agents that would otherwise make multiple API calls.
The get_product_details tool returns all merchant listings, not just the cheapest. Agents receive merchant names, prices, currencies, and purchase links for each product. This enables price comparison without querying individual retailer sites.
Authentication and Rate Limits
The free tier allows 100 MCP tool calls per day. This quota is per developer account, not per agent instance. Multiple agents running under the same account share the quota.
At 100 calls per day, agents can sustain approximately 4 queries per hour. Continuous polling or multi-agent deployments will exhaust quota within hours.
Rate limiting is enforced per developer account. Reset timing is not documented. Paid tier pricing is not published on the developer portal.
Schema Handling
Seekon.me returns only non-null fields. No schema versioning mechanism is documented. Breaking changes (field removal, type changes) are not communicated via changelog or webhook.
If a field disappears, your agent receives an object with that key omitted. This requires:
- Defensive parsing: check for field existence before accessing.
- Fallback logic: if a required field is missing, skip that product or query another tool.
- Monitoring: log schema drift to detect when tool descriptions need updates.
Failure Modes
| Failure | Cause | Mitigation |
|---|---|---|
| Empty results | Category mismatch or no inventory | Retry with broader query; log category mismatches to identify taxonomy gaps |
| Missing merchant links | Retailer data unavailable | Fall back to product page, notify user |
| Rate limit exhaustion | Quota exceeded | Queue requests, cache aggressively |
| Missing fields | Schema changes | Defensive parsing, monitor null rates |
The biggest operational risk is rate limits. At 4 calls per hour, agents that query frequently will exhaust the quota quickly.
Deployment Shape
Seekon.me is a hosted service. You do not run the MCP server yourself. The integration points:
- MCP client in your agent runtime (Claude Desktop, LangGraph, custom Python).
- API key from the developer portal.
- Tool descriptions in your agent’s system prompt.
MCP server connection details are provided in the developer portal after account creation.
Seekon.me does not expose built-in observability. Instrument at the client layer to log:
- Tool call latency (network plus processing).
- Result counts (how many products returned).
- Schema null rates (track missing fields over time).
No built-in tracing or metrics endpoint is documented.
Comparison to Scraping
| Dimension | Web Scraping | Seekon.me API |
|---|---|---|
| Brittleness | Breaks on DOM changes | Stable schema (non-null fields only) |
| Rate limits | IP bans, CAPTCHAs | 100 calls/day free tier |
| Merchant coverage | One site per scraper | Multi-merchant aggregation |
| Legal risk | Terms of service violations | Terms of service explicitly permit agentic access (not documented in source material) |
The API wins on stability and legal clarity. Scraping requires maintaining selectors and handling anti-bot measures.
Limitations and Unknowns
The source material does not document:
- Pricing: paid tier costs, volume discounts, or sales contact.
- Schema versioning: how breaking changes are communicated.
- Sync latency: how often merchant data is refreshed.
- Category detection algorithm: internal, not disclosed. Search ranking and merchant aggregation logic: not documented.
- Rate limit reset: daily, hourly, or other cadence.
- Observability: built-in metrics, tracing, or error reporting.
These gaps mean you discover operational constraints at runtime.
Technical Verdict
Use Seekon.me if you need structured product data for multi-merchant shopping agents and want to avoid scraping fragility. The MCP tool interface is minimal (two tools, single query string per tool), reducing integration surface area and debugging complexity. The schema returns only non-null fields, and the free tier (100 calls per day, approximately 4 queries per hour) supports single-agent prototyping but not continuous polling or multi-agent deployments.
Avoid if you need more than 100 queries per day without documented paid tier pricing or volume discounts. The lack of documented versioning means you discover breaking changes when tool calls return unexpected shapes, so defensive parsing is mandatory.
For production agents, budget for the paid tier and instrument client-side observability. The API does not expose operational metadata, so you need your own logging to debug latency spikes or schema drift.