Book an India visa from your own agent

Overview

The server speaks the Model Context Protocol over Streamable HTTP. Point any MCP client at the endpoint above; the client discovers the tools and drives them. Every call acts on behalf of a signed-in Naytive user, so the visa is filed against a real account with a real document vault.

Get an API key

Every call carries a Naytive partner API key in the X-API-Key header, so all usage is attributed to your integration and billed to your wallet. Keys are issued by Naytive — request one below and we'll approve it and send your key (shown once).

Connect a client

The endpoint is a standard remote MCP server, so anything that speaks MCP works. On first use the client opens a browser window for the user to sign in, then remembers the session.

Claude Desktop / Claude Code

Add the server to your MCP config (Claude Code: run the CLI command; Desktop: edit claude_desktop_config.json). Set your partner key as the X-API-Key header. Optionally add X-Stripe-Key (a restricted Stripe key) to collect end-user payments on your own Stripe — see Wallet & billing.

// mcpServers entry
{
  "mcpServers": {
    "naytive-visa": {
      "type": "http",
      "url": "https://visa-mcp.naytive.com/mcp",
      "headers": {
        "X-API-Key": "oc_test_your_key_here",
        // optional — collect on your own Stripe:
        "X-Stripe-Key": "rk_test_your_restricted_key"
      }
    }
  }
}

claude mcp add --transport http naytive-visa https://visa-mcp.naytive.com/mcp \
  --header "X-API-Key: oc_test_your_key_here"

Cursor

Add to ~/.cursor/mcp.json (or the project's .cursor/mcp.json) with the same shape — "url" pointing at the endpoint and an X-API-Key header.

MCP Inspector

The quickest way to click through the tools. Use v2+, which supports the OAuth sign-in:

npx @modelcontextprotocol/inspector@latest

In the UI: Add Server → Transport Streamable HTTP → URL the endpoint → toggle it on → complete the Naytive sign-in.

Custom client (TypeScript SDK)

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://visa-mcp.naytive.com/mcp"),
  { authProvider }  // your OAuthClientProvider — SDK runs the PKCE flow
);
const client = new Client({ name: "my-agent", version: "1.0.0" }, { capabilities: {} });
await client.connect(transport);

const { tools } = await client.listTools();
const res = await client.callTool({ name: "list_india_events", arguments: {} });

Try it

Run any tool live, right here. Every call needs your X-API-Key. Wallet & catalog tools run with just the key; traveller tools also need a Bearer access token.

// the response will appear here

Tip: run list_india_events first to get a visaConfigId, then paste it into get_visa_details.

Authentication

Two layers. Your partner API key (X-API-Key) identifies your integration on every request and is what your wallet is billed against. On top of that, user-scoped tools need the traveller's Privy sign-in (OAuth 2.1). A request with no key returns 401; a user tool with no sign-in returns 401 + WWW-Authenticate, which a compliant client uses to run the browser sign-in automatically.

1. Set your Naytive-issued key as the X-API-Key header (see Get an API key). It never expires unless revoked.
2. For a user-scoped tool, the client opens the authorize URL; the server redirects to Naytive's hosted sign-in, where the traveller logs in with email or wallet (Privy).
3. Naytive verifies the identity and the server issues a short-lived access token bound to that user. The client sends it as Authorization: Bearer … alongside your X-API-Key.

{
  "issuer": "https://visa-mcp.naytive.com/",
  "authorization_endpoint": ".../authorize",
  "token_endpoint": ".../token",
  "registration_endpoint": ".../register",
  "code_challenge_methods_supported": ["S256"],
  "grant_types_supported": ["authorization_code", "refresh_token"]
}

Wallet & billing

Two ways to collect payment from your end-user — you choose per connection with the optional X-Stripe-Key header:

Tools

Twelve tools, grouped by what they touch. Read tools return catalog, account, or wallet data; write tools mutate the user's vault, applications, or your wallet. Every tool returns a JSON payload as text content. All tools require your X-API-Key; user-scoped tools also need the traveller's sign-in.

Catalog

Applications

Documents

Submit & pay

Wallet & billing

Filing a visa, end to end

A typical agent conversation walks the user from "what can I get" to a filed, paid application. The server owns the rules; the agent just calls tools in order.

1. Discover

   list_india_events → pick a visa and event. get_visa_details for pricing and the document checklist.

2. Check the vault

   get_required_documents shows what the user already has stored versus what's still needed.

3. Collect documents

   upload_passport and upload_photo for anything missing. Keep the returned documentId and photoId.

4. Fund your wallet

   Once, up front: get_wallet_balance to check funds; create_wallet_topup_link if you need more. Your end-user pays you separately, through your own Stripe.

5. File

   submit_application with the ids, dates, and event. Naytive's fee is debited from your wallet and the application is filed — it returns an applicationNumber already submitted.

6. Track

   list_applications / check_application_status — the application reads submitted and moves through review.

Errors & limits

Tool errors come back as text content with isError: true and a plain message. A few things worth knowing before you build against it.

• Wallet debits are atomic & idempotent. A submitted application is charged once; a retry is never double-charged and the balance can't go negative. Top-ups are credited by the Stripe webhook, not from the client claiming success.
• Documents belong to the signed-in user. A tool can only reference documents and applications owned by the authenticated account.
• Staging Stripe is in test mode — use a test card at checkout.