Hosted MCP endpoint

Connect WildNDGo to your AI client

Use one remote endpoint for developer utilities, test data, image processing, and finance helpers. Plans, quotas, and usage are enforced per key, and every tool now returns the same top-level response envelope.

See Pricing Plan JSON

1. Use the hosted endpoint

All plans point at the same base URL. Your key determines the plan, included tools, and remaining billable units.

https://wildndgo.com/mcp/

Authentication

Authorization: Bearer YOUR_WILDNDGO_KEY
or
X-API-Key: YOUR_WILDNDGO_KEY

Live billing endpoints

GET /mcp/billing/plans   -> public plan catalog
GET /mcp/billing/usage   -> current key usage snapshot

2. Quick setup examples

Start with the billing endpoints to confirm your key, then point your MCP-compatible client at the hosted URL.

Check the public plan catalog

curl https://wildndgo.com/mcp/billing/plans

Check your current usage

curl \
  -H "Authorization: Bearer YOUR_WILDNDGO_KEY" \
  https://wildndgo.com/mcp/billing/usage

Retry a tool call safely

POST /mcp/
Authorization: Bearer YOUR_WILDNDGO_KEY
Idempotency-Key: 9c5233d5-4c7b-4d6d-97ae-demo

Use the same Idempotency-Key when retrying the exact same tools/call request.
WildNDGo replays the first completed response and does not charge usage twice.

Python MCP client example

import asyncio
import httpx

from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client


async def main() -> None:
    headers = {"Authorization": "Bearer YOUR_WILDNDGO_KEY"}
    async with httpx.AsyncClient(headers=headers, follow_redirects=True, timeout=30.0) as http_client:
        async with streamable_http_client("https://wildndgo.com/mcp/", http_client=http_client) as (read, write, _):
            async with ClientSession(read, write) as session:
                await session.initialize()
                tools = await session.list_tools()
                print([tool.name for tool in tools.tools])


asyncio.run(main())

3. Stable tool response contract

Every tool response now uses the same top-level fields so AI callers can branch on success, inspect warnings, and handle errors without tool-specific parsing.

Success envelope

{
  "ok": true,
  "tool": "generate_uuid",
  "schemaVersion": "2026-05-13",
  "requestId": "wreq_ab12cd34ef56",
  "data": {
    "generatedCount": 2,
    "items": ["...", "..."]
  },
  "warnings": [],
  "meta": {
    "billableUnits": 1,
    "deterministic": false
  }
}

Error envelope

{
  "ok": false,
  "tool": "format_json",
  "schemaVersion": "2026-05-13",
  "requestId": "wreq_98fe76dc54ba",
  "error": {
    "type": "invalid_request_error",
    "code": "invalid_json",
    "message": "Expecting value",
    "param": "text",
    "retryable": false,
    "docUrl": "https://wildndgo.com/mcp-access"
  },
  "warnings": [],
  "meta": {
    "billableUnits": 1
  }
}

Image tools now default to metadata mode

convert_image(
  image_base64="data:image/png;base64,...",
  output_format="webp",
  response_mode="metadata"
)

Returns size, dimensions, mime type, savings, and a retrieval hint.
Only set response_mode="inline_base64" when the caller really needs bytes inline.

Seeded reproducibility for random tools

generate_uuid(
  count=2,
  seed="demo-seed-1"
)

generate_identity(
  country="cn",
  count=2,
  seed="demo-seed-1"
)

The same seed returns the same generated output for supported random tools.

Request tracing headers

Request-Id: wreq_...
X-Wildndgo-Request-Id: wreq_...

Every HTTP response exposes the request id in headers.
Tool envelopes also include requestId so logs and tool results can be matched.

Calling guidance for AI agents

Branch on ok first, then inspect data or error.
Use requestId when logging or reporting a failed call.
Reuse the same Idempotency-Key only for the exact same retry request body.
Read warnings for clamped counts, lengths, quality, or resize limits.
Use the same seed when you need reproducible UUID, identity, password, or card outputs.
Prefer metadata image responses unless you actually need inline base64 output.

4. What the key controls

Your WildNDGo API key is no longer just an allow-list token. It also controls plan gating and unit-based quotas.

Every tool response includes ok, tool, schemaVersion, requestId, warnings, and meta.
Structured error objects include type, code, param, retryable, and docUrl fields.
HTTP responses include Request-Id and X-Wildndgo-Request-Id headers for tracing.
POST tool calls can use Idempotency-Key to safely retry without double billing.
Random tools can accept a seed so the same request can be replayed deterministically.
The Free plan only exposes low-cost utility tools.
Paid plans unlock image, identity, credit-card, and mortgage tools.
Daily and monthly billable units are enforced automatically.
Each authenticated key can inspect its own usage through /mcp/billing/usage.
Image tools default to response_mode=metadata so agents do not receive large inline payloads by default.
Response headers include plan and remaining monthly units for easier monitoring.

Use /pricing for the commercial breakdown and /mcp/billing/plans for the machine-readable plan catalog your onboarding flow can consume.