Keyra for developers

Build the trust layer into your application.

Build with the tools you already use. Connect your application to Keyra identity and authorization infrastructure, protect consequential digital actions, and create trusted experiences for humans, organizations, devices and AI.

Start buildingExplore developersView documentation

Developer experience

Build trust the way you already build.

Vibe-code with authoritative resources, or integrate through standard software interfaces — no card engineering required.

Vibe coding

Vibe code trust into your app.

Tell your coding environment where trust matters. Use authoritative Keyra developer resources to help implement the appropriate authentication or authorization flow.

Prompt
Add Keyra authorization before this user can access a protected action.
  1. Developer intent
  2. AI coding environment
  3. Keyra documentation / SDK / API
  4. Implementation
  5. Sandbox test
  6. Verified result

AI assistants do not automatically know Keyra architecture. Implementation must reference authoritative resources at developer.keyra.ie.

Accessibility

You don't need to become a card engineer.

Any developer can build with Keyra.

Developers build against approved Keyra software interfaces. Keyra handles the underlying trust infrastructure appropriate to the implementation.

  1. Build your app
  2. Connect Keyra
  3. Define trust event
  4. Test
  5. Deploy

Trust infrastructure included

Verification, authorization, and identity — managed by Keyra while you ship your product.

Platforms & patterns

Meet your stack. Choose your path.

Build in the environments you use today, then connect through validated Keyra integration patterns.

Build where you build

Keyra meets you where you code.

Compatible development workflows — build Keyra into applications created with your preferred tools.

Selected environment

AI coding

Build Keyra into apps created with these ai coding tools.

  • Cursor
  • Claude Code
  • OpenAI Codex
  • GitHub Copilot
  • Windsurf
  • Replit
  • ChatGPT-assisted development

No official partnership implied — build with the tools you already use.

Real integration paths

Validated paths — choose the right pattern.

OAuth Verify and Partner 2FA serve different roles. Do not collapse them into a generic security API.

Available now

Passwordless

Keyra OAuth Verify

For applications where Keyra is used as the authentication experience. Browser starts with a publishable client id; your backend validates before creating a session.

Build OAuth Verify →
Available now

Step-up security

Keyra Partner 2FA

Add Keyra verification to an existing authentication system. Keep your primary login; enroll and step-up with Keyra on your backend.

Build Partner 2FA →
Explore SDKs →View API reference →

Choose OAuth Verify for passwordless sign-in, or Partner 2FA when you already have login and need Keyra step-up verification. Follow docs for the pattern that matches your app.

Integration path

Build. Connect. Test. Authorize. Ship.

01

Build

Create the application using your preferred tools.

02

Connect

Create or select a Keyra project. Use appropriate developer credentials.

03

Implement

Choose the supported Keyra integration pattern.

04

Test

Use the Keyra sandbox project environment.

05

Authorize

Execute the supported verification or authorization experience.

06

Verify

Backend receives and enforces the trusted result.

07

Ship

Complete production requirements and deploy.

Code. Verify. Authorize. Ship.

Security boundary

Secrets never belong in the browser.

Browser: publishable credentials only where supported. Server: secret credentials. Your backend is the trust boundary.

Browser
Publishable ID (cp_*)Keyra
Server
Secret credential (sk_*)Keyra
project.config.json — sandbox example
{
  "project": "my-app",
  "environment": "sandbox",
  "callback_url": "https://app.example.com/callback",
  "api_keys": {
    "publishable": "cp_test_••••••••",
    "secret": "sk_test_••••••••"
  },
  "auth_backend": "https://auth.keyra.ie"
}

Credential formats and restrictions are defined in Keyra developer documentation. Never expose secret keys in client-side code.

Beyond login

Login is only one moment of trust.

Protect the action, not only the session.

  • Sign in
    Docs →
  • Account recovery
    Concept
  • Access data
    Concept
  • Open file
    Concept
  • Share file
    Concept
  • Download information
    Concept
  • Change permissions
    Concept
  • Admin action
    Concept
  • Approve workflow
    Concept
  • Financial authorization
    Developer preview
  • Release asset
    Concept
  • Authorize AI action
    Developer preview
  • Change security settings
    Concept

  • Keyra protects consequential actions — not only sign-in. Status labels show what you can build today versus what is still forming.

    Design note

Trust in practice

Authorization moments and AI authority.

Simulate user-facing trust flows and model how humans retain authority over consequential AI actions.

Authorization moments

Where trust meets the user experience.

Interactive simulations. Not all flows represent current physical-card tap behavior unless labelled otherwise.

Available now

OAuth Verify flow — software authorization, not necessarily physical card tap.

  1. Sign in with Keyra
  2. Keyra authorization
  3. Identity verified
  4. Session started

AI authority

AI can request. Humans can authorize.

As AI systems perform consequential actions, applications need explicit authority boundaries. Keyra provides trust infrastructure for this pattern — not universal autonomous-agent compatibility.

  1. AI agent
  2. Action request
  3. Keyra
  4. Authorized human / authority
  5. Decision
  6. Allow / Deny

Humans retain final authority. Agents request — people approve or deny.

Developer tools

Keyra Developer Client — coming soon

A future desktop client for developer authentication, project management, sandbox access, SDK discovery, test workflows, and diagnostics. No download available yet.

Coming soonDesktop client · no download yet
  • Developer authenticationSign in to projects and sandbox environments from one client.
  • Project managementCreate, switch, and manage Keyra projects without the browser.
  • Local environment setupGuided setup for SDKs, credentials, and dev tooling.
  • Sandbox accessConnect to sandbox projects with fewer manual portal steps.
  • SDK discoveryBrowse supported Keyra SDK packages and install paths.
  • Test workflowsRun verification and authorization flows against sandbox.
  • DocumentationImplementation recipes and docs surfaced inside the client.
  • DiagnosticsValidate configuration and surface actionable fix guidance.

One click where possible. One guide where not — setup guides live at developer.keyra.ie/docs.

Developer economy

Program utility and network effects.

Qualifying authorization activity can create developer participation — while adoption compounds across the ecosystem.

Developer program

Security can become application utility.

Under applicable Keyra Developer Program terms, qualifying authorization activity may create economic participation for developers.

  1. Developer builds
  2. Users interact
  3. Keyra secures qualifying action
  4. Authorization event
  5. Qualifying program event
  6. Developer economic participation

Program terms govern eligibility — authorization activity must qualify under applicable developer program rules.

Explore the developer program

Network effects

The Keyra developer economy

Each integration increases trust moments — compounding value for builders and users across the network.

  1. More developers
  2. More applications
  3. More users
  4. More trust moments
  5. More Keyra authorization activity
  6. More developer value

Compounding by design

Every new integration expands the trust surface area. More authorization activity creates more developer value — and draws more builders into the ecosystem.

Build with evidence

Developer portal and trust center.

Manage projects and credentials in the portal — then review architecture, privacy, and authorization guidance when you need it.

Developer portal

Projects, keys, and team — where supported.

Workspace modules at developer.keyra.ie for projects, API keys, usage, and team collaboration.

  • ProjectsSandbox & production
    Available now
  • API keysPublishable & secret
    Available now
  • UsagePer-key analytics
    Available now
  • TeamCollaborators
    Available now
  • Economic eventsProgram-dependent
    Concept
  • SettlementProgram-dependent
    Concept
Open developer portal

Roadmap

In development — not marketed as available

Concept capabilities on the horizon. Not represented as current product availability.

  • Keyra MCP serverDocumentation, schemas, implementation recipes
    Concept
  • Keyra CLILogin, project init, diagnose configuration
    Concept
  • Official starter applicationsMaintained by Keyra when released
    Concept
  • AI-native documentationllms.txt, machine-readable index, copy-for-AI blocks
    Concept

Roadmap items may change. Follow developer documentation for what is available today.

Failure states

Errors should explain what happened, why, and how to fix.

Select an error pattern for context and documentation links — designed for developer clarity, not opaque failure codes.

Error pattern

Credential error

What happened

Invalid or mismatched API key.

Why

Publishable and secret keys are scoped to environment and project.

How to fix

Verify cp_* / sk_* prefixes match sandbox or production in the developer portal.

Start building

Your app. Your environment. Keyra trust.

Build where you build. Secure what matters.

Start buildingView documentation