Skip to content

Integrating platforms

Give your customers non-repudiable approvals β€” under your brand.

A payroll service, a treasury tool, a signing workflow: your product already has the users, the UI and the moment where someone must commit to something irreversible. INTYGA supplies the missing piece β€” a passkey signature bound to the exact bytes, with a tamper-evident record behind it β€” white-label. Your users never hold an INTYGA account and never see an INTYGA page: every ceremony runs on your own domain. And because your requests carry your customers' financial or personal data, INTYGA receives a digest of each payload, never the payload.

For platforms

Embedded

Custom quoted per platform

Put human approvals inside your own product, under your own brand, for your own customers. Build and try the whole integration on test Relying Parties first: they are unlimited and free on every plan, and they never count toward your band.

  • A monthly platform fee plus a band of monthly active approvers
  • A month above your band is trued up on the next invoice, never stopped
  • Signatures never charged or refused
  • Unlimited live Relying Parties, under your own brand
  • 3-year hosted evidence and bulk export
  • SSO and SCIM, four-eyes / SoD for your own operators
Example Β· one action, end to end

One end-user signature, on your own page

Your platform asks one of its users to approve a payout. The ceremony runs on your domain, in your UI; INTYGA receives only a digest and returns a receipt your backend verifies before it pays.

  1. Step 1: Your code asks

    Your backend asks for a signature over the exact payload, for one of your users, on your own origin.

    import { IntygaPlatformClient }
      from "@intyga/sdk"
    
    const intyga =
      new IntygaPlatformClient({
        gatewayUrl, clientId, privateKey,
      })
    const payload = {
      payout: "example-payout-7",
      amount: "480.00",
      currency: "EUR",
    }
    
    // INTYGA receives only a digest.
    const challenge =
      await intyga.requestSignature({
        externalId: "example-user",
        payload,
        origin: "https://app.example.com",
      })
  2. Step 2: Your user sees

    Your page shows the payload you hashed and runs the passkey ceremony on your domain. INTYGA renders nothing here.

    Approve payout of 480.00 EUR
    Your page, your design β€” rendered from the payload you hashed.
    payout
    example-payout-7
    amount
    480.00
    currency
    EUR
    Approve with passkey
    Passkey for example.com β€” on your own domain
    Illustration with example values: your own approval page β€” the payload fields and a passkey prompt on your domain.
  3. Step 3: Your code gets back

    A receipt over those exact bytes. Your code checks it, then acts.

    The receipt, shortened
    {
      "canonicalPayload": "{\"v\":2,…}",
      "payloadHash": "3f6a9c…",
      "rpId": "example.com",
      "subject": {
        "externalId": "example-user"
      },
      "signatures": [
        {
          "signerDid": "did:intyga:…",
          "sigAlg": "WEBAUTHN",
          "signature": "MEUCIQ…"
        }
      ],
      "verificationCode": "A1B2-C3D4"
    }
    const { receipt } =
      await intyga.completeSignature(
        challenge.nonce, assertion)
    
    // Offline, from your own records.
    const verdict = intyga.verifyReceipt(
      receipt,
      { tenantId: WORKSPACE_ID,
        approvers: { publicKeys: [key] },
        payloadHash: hashPayload(payload),
        rpId: "example.com",
        nonce: challenge.nonce },
      { expectedOrigin:
          "https://app.example.com" },
    )
    if (!verdict.ok)
      throw new Error(verdict.reason)
    
    // Only now does the operation run.
    await releasePayout(payload)

All names and values are examples. The receipt is shortened; the full shape is in the verification reference.

The integration point

You provision subjects β€” your users, named by an opaque id you choose. Who that id belongs to remains your claim: you attach the identity-assurance metadata (how you verified the person), and it is recorded and witnessed verbatim, never asserted by INTYGA.

  1. Register your domain as a Relying Party and enroll each user's passkey from your own page β€” your backend relays the ceremony, INTYGA verifies it against your registered origin.
  2. To sign, canonicalize your payload once, hash it, and relay the signing ceremony. The user's passkey signs over the digest, your RP identity, the subject, and the moment.
  3. Verify the receipt in your own service, against the digest you recompute and the keys you enrolled β€” no call to INTYGA, no INTYGA secret.

The credential scoping does real work here: a passkey enrolled under your Relying Party is cryptographically bound to it by the browser and the authenticator themselves. A staging RP and a production RP can never vouch for each other, and nothing enrolled anywhere else can sign for you.

Behind every receipt sits the witness ledger: enrollment, revocation, each signature and each refusal land as committed, hash-chained entries, and a receipt carries its ledger position so its inclusion proof can be fetched and checked against anchored roots. INTYGA holds no key capable of producing a valid approval β€” the evidence does not depend on trusting us.

What the receipt proves β€” and what stays yours

A platform receipt attests that this enrolled key signed this digest at this time, on this Relying Party. It deliberately does not attest what your UI displayed β€” that guarantee moves to you, and keeping it is one rule: render the approval screen and execute the action from the same canonical serialization you hashed. The developer guide walks through exactly this discipline, because a platform that rebuilds its payload between approval and execution has a receipt that proves nothing about what ran.

For example, when your treasury tool asks a user to approve a €100 payment, render the screen, compute the digest and execute the payment from one canonical instruction, and verify the receipt in your own service against the digest you recompute and the keys you enrolled. If the amount becomes €1,000, ask again: the receipt covers the original digest, not the changed payment.

Build against test mode, ship against the same API

Mark a Relying Party as test mode and everything stays fully real β€” real ceremonies, real receipts, real ledger entries β€” but nothing is billed and nothing counts toward usage. Test mode is loopback-only (localhost, 127.0.0.0/8, or::1); reserved and private-DNS names can serve real users, so shared staging RPs are registered live. The API stays the same when you ship. A runnable demo platform ships in the repository, exercising the whole loop against a local gateway with a real browser passkey or headlessly.

Build it on test mode. Talk to us when you go live.

Test Relying Parties are free and unlimited on every plan, so the whole loop β€” enrollment, signing, offline verification and the witness ledger β€” can run on your machine before anything is signed with us. When real customers come next, the Embedded plan is quoted for your audience.