For MCP developers

Add identity and consent to your MCP server.

Give every agent that hits your MCP server a verified human behind it and a scoped, signed mandate for what it can do. One SDK, FIDO2 under the hood, no auth stack to build.

Get API keysRead the docs
FIDO2·MCP-ready·TypeScript·SOC 2
server.ts: verify before tool call
server.tool("checkout", async (args, ctx) => {
  // require a verified human + scoped mandate
  const { token } = await loginid
    .verifyPasskey({ user: ctx.user });
 
  const mandate = await loginid.createMandate({
    token,
    scope: { maxAmount: 200, currency: "USD" },
  });
 
  return runCheckout(args, mandate);
});

Quickstart

Live in three calls.

Drop verified human identity and signed agent mandates into your MCP server without building an auth stack. Start in test mode in minutes.

  1. 01

    Get your API keys

    Create a project in the dashboard and grab a test-mode publishable + secret key. No sales call to start building.

  2. 02

    Install the SDK in your MCP server

    Add one TypeScript-first dependency. No credential storage, no WebAuthn plumbing, no auth stack to stand up.

  3. 03

    Verify the human, scope the agent

    Run the passkey ceremony, mint a scoped mandate, and confirm the signed tool call: three calls, fully revocable.

Get API keysRead the docs
server.ts
// 1. Install the SDK//    npm i @loginid/sdk // 2. Initialize with your API keyconst loginid = createClient({  apiKey: process.env.LOGINID_API_KEY,}); // 3. Verify the human behind the agentconst { token } = await loginid.verifyPasskey({ user });

Illustrative: see docs.loginid.io for the full API

What is agent identity for MCP servers?

An MCP (Model Context Protocol) server exposes tools that AI agents call on a user's behalf, but the protocol doesn't tell you who the human behind the agent is or what they actually approved. LoginID closes that gap: before a tool runs, you verify the human with a passkey and attach a scoped, signed mandate that limits what the agent may do. The result is a known, accountable actor on every tool call instead of an anonymous client.

Built for the way agents call tools.

Drop-in for any MCP server

Wrap sensitive tools with a single verification call. Works with any MCP-compatible client or agent framework.

Scoped, signed mandates

Bound by amount, merchant, and intent: cryptographically signed, time-boxed, and revocable on demand.

Phishing-resistant by default

Passkey-centric, so there's no shared secret to steal, replay, or phish. FIDO2-certified at NIST AAL2.

Webhooks & audit trail

Stream verification and mandate events to your backend with a complete, non-repudiable record of who approved what.

Frequently asked questions

How do I add LoginID to an existing MCP server?
Install the SDK, initialize it with your API key, and wrap the tools that need a verified human with verifyPasskey() before the tool body runs. You can start in test mode with no integration call, then move to production keys when you're ready.
Do I need to handle passkeys or WebAuthn myself?
No. The SDK runs the full passkey (FIDO2/WebAuthn) ceremony for you and returns a token you can attach to a mandate. You never touch a raw credential or build credential storage.
What is a mandate and why scope it?
A mandate is a scoped, signed grant of what an agent may do, for example spend up to $200 USD at one merchant within 15 minutes. Scoping it keeps an autonomous agent inside explicit limits and gives you a non-repudiable record of the human's consent.
Which languages and frameworks are supported?
The SDK is TypeScript-first and works in any Node-based MCP server or agent tool, with REST APIs available for other stacks. See the docs for current language coverage.
Is it free to start?
Yes. Create an account, grab test-mode API keys, and integrate without talking to sales. Production usage and volume pricing are covered in the dashboard and docs.

Go deeper across the platform

Agent AuthenticationAuthenticate agent origin and bind it to a verified human identity.Explore Agent AuthorizationGrant authenticated agents narrow, signed, revocable permission to act.Explore Agent PaymentIssue scoped agentic payment tokens you can account for.Explore

Integration walkthrough

Verify, scope, confirm, in one flow.

Inside your MCP tool handler, prove the human with a passkey, mint a scoped mandate, then confirm the signed action. One SDK handles the ceremony, the scope, and the signature, so you never touch a raw credential.

  • Passkey-backed proof of the human, not just the agent
  • Scoped, signed, revocable mandates by amount, merchant, and intent
  • FIDO2 under the hood; works with any agent or MCP client
Read the integration guide
agent-checkout.ts
// 1. Verify the human behind the agentconst { token } = await loginid.verifyPasskey({ user }); // 2. Scope what the agent may doconst mandate = await loginid.createMandate({  token,  scope: { maxAmount: 200, currency: "USD" },  expiresIn: "15m",}); // 3. Confirm the signed transaction at checkoutawait loginid.verifyTransaction(mandate.id);

Illustrative: see docs.loginid.io for the full API

Ship verified agents this week.

Grab your API keys, install the SDK, and add a verified human to every MCP tool call, with a single integration.

Start buildingBook a demo