Developers

Build on Turtini.Ship into the network from day one.

Most of building alone is rebuilding what already exists — auth, billing, identity, trust, calendar, discovery. Turtini ships the primitives so you author the part that's actually yours, and your module is discoverable to every other org on the platform the moment it goes live.

Start a module@turtini/sdk on npm

Identity graph, trust fabric, folio bus inherited
In every Turtini org's marketplace at launch
SDK + CLI + MCP — pick your surface
90/10 rev share, no platform fee to ship

Plug in, not silo

Your idea, in the neighborhood — not in an empty IDE.

A solo-built tool ships into a network of one. A Turtini module ships into a network of every business, household, school, team, and venue already running on the platform. Same code effort. Different outcome.

Building alone

You author auth, billing, calendar, identity from scratch
Your users have to discover you, one at a time
Trust is earned per-account, every time
Integrations are a roadmap, not a starting point

Building on Turtini

You inherit the identity graph, folio bus, trust fabric, Wally
Every Turtini org sees your module in their marketplace
Verified-by-Turtini credentials make trust portable across orgs
Your module joins existing primitives — discovery is instant

Install

Three surfaces — pick where you want to live.

@turtini/sdk

Module SDK + Public API client

npm i @turtini/sdk

React hooks, design tokens, typed client for the Turtini Public API. Drop into any React app to call any Turtini endpoint.

View on npm →

@turtini/cli

Scaffold + build + publish

npm i -g @turtini/cli

create-turtini-module scaffolds a module. turtini-dev serves it locally against your scratch org. One command to publish.

View on npm →

@turtini/mcp

Wire Claude Code to Turtini

npm i -g @turtini/mcp

Model Context Protocol server. Give Claude Code (or any MCP client) direct read/write access to your Turtini org so it can author modules with full context.

View on npm →

Already shipping

Built on Turtini

Live modules authored by partners. Every one is discoverable from every Turtini org's marketplace the moment it goes live.

No partner modules yet — be the first.

Scaffold one with the CLI; it shows up here the moment it's approved.

Start a module →

Primitives you inherit

What plugging in actually gets you.

Identity graph

One human, one canonical account, every email/phone/handle linked. Your records resolve automatically.

Trust fabric

Ed25519-signed Verifiable Credentials. Anyone can verify offline. Your module inherits the badge.

Folio bus

Charges flow into rooms, retail orders, F&B checks. Send a charge, and it lands where it should.

Wally

The platform assistant. Your module exposes tools; Wally calls them with confirmation cards.

Personal Vault

Users own their data. Counterparty grants are auditable both directions. You read with permission.

Marketplace + Templates

Your module + your templates are live in every org's marketplace the moment they ship.

Block Marketplace

Publish blocks via the SDK or register an https:// URL of an app you host elsewhere. 90/10 rev share, sandboxed, identity-bridged.

Domain services

Cloud Run domain pattern with auth + error funnel built in. Add a route, not a service.

Unified calendar

Events from any module flow into every user's calendar via subscription, not copy.

Image moderation

Every upload runs through SafeSearch + admin queue. Your module participates by default.

Continue with Turtini

Let people bring their verified identity to your site.

Turtini is a standard OpenID Connect provider — but unlike a generic login button, your users bring a real, portable identity they own: one account for life, carrying their Turtini credentials and org membership. Add the button with a script tag, or point any OIDC library at the discovery URL. The same person is the same stable identity on every site.

Discovery URL

https://api.turtini.com/.well-known/openid-configuration

Drop-in button (snappy popup, no backend)

<script src="https://turtini.com/turtini-signin.js"></script>
<div id="turtini-btn"></div>
<script>
  Turtini.init({ clientId: "your-client-id", scope: "openid profile email" })
  Turtini.renderButton("#turtini-btn", {
    onSuccess: ({ idToken, claims }) => {
      // claims = { sub, email, name, picture, ... }
      // returning users sign in with one tap (silent re-approval)
    },
  })
</script>

Or any OIDC library (NextAuth / Auth.js)

providers: [
  {
    id: "turtini",
    name: "Turtini",
    type: "oidc",
    issuer: "https://api.turtini.com",
    clientId: process.env.TURTINI_CLIENT_ID,
    clientSecret: process.env.TURTINI_CLIENT_SECRET,
    authorization: { params: { scope: "openid profile email" } },
  },
]

One Tap

Pre-click prompt via FedCM, no popup

id_token

RS256 JWT, verify against JWKS

PKCE

S256 supported (public clients)

No org required

Any Turtini user can sign in

renderButton automatically shows the browser-native One Tap ("Continue as …") to signed-in Turtini users — no click, no popup. It falls back to the button anywhere FedCM isn't available.

To get a client_id +client_secret, email [email protected].

Your work, in the neighborhood.

Building alone makes hope. Building on Turtini makes leverage. Same code; different orbit.

Start a modulePartner Program

Open protocols · public credentials · portable identity · jwks.json