Skip to main content
A signer is a cryptographic identity authorized to approve actions on a Crossmint wallet. Possession of the secret is the whole proof — the wallet checks the key, not intent. Signer security is therefore about two decisions: where the secret lives and how much authority it carries.
A leaked signer secret can be used to drain a wallet without going through Crossmint at all — the attacker signs directly against the wallet’s contract. Protecting signer secrets is your responsibility as a wallet operator.

Best Practices by Signer Type

Each signer type is secured differently. Apply the practices that match the signers your wallets use.

Device Signer and Passkey

The private key lives in a hardware-backed keystore and cannot be extracted — but it still signs whatever payload reaches it.
  • A passkey requires biometrics or a device PIN on every transaction — prefer it where silent signing is unacceptable.
  • For device signers, recommend that users enable biometric authentication so no signature happens silently.
  • Keep your dependencies clean. A compromised dependency or an injected script in your frontend can replace the transaction payload in memory before it reaches the keystore — pin and audit your dependencies, and use a supply-chain security layer such as Chainguard.

Server Signer

The keypair is derived locally from a single secret — whoever holds that secret holds the signer and can sign directly against the wallet, bypassing your backend and Crossmint entirely.
  • Treat the derivation secret as the signer itself. Store it in a secrets manager or behind dedicated key management (a cloud KMS provider, an MPC/HSM-backed service) — never in application configuration, git, CI logs, or client-side code, including framework public environment variables (NEXT_PUBLIC_, EXPO_PUBLIC_, and similar prefixes). Treat any secret that has ever appeared in a repository or build artifact as compromised.
  • Grant read access only to the service or process that signs.
  • If your backend signs routine operations, register the server signer as a scoped operational signer and keep the recovery method a separate key (for example Cloud KMS or a quorum). A server signer used as the recovery method cannot be scoped.

Cloud KMS Signer

Nobody can read the key, but KMS signs any payload sent by an identity allowed to use it — a leaked cloud credential or over-privileged IAM role is enough.
  • Grant only the sign permission (for example roles/cloudkms.signerVerifier or kms:Sign) to the single service that signs.
  • Require IAM authentication on the signing function.
  • Alert on the cloud audit log for every signing call.
  • For sensitive operations — or when the key backs a recovery method — require an explicit human approval before signing.
  • If the provider supports it, keep signing permissions disabled and enable them only when an operation needs them.
  • If access is abused, revoke the IAM permission. Signing stops immediately, without a signer change on the wallet.

Email and Phone OTP

Takeover of the user’s email account or phone number (SIM swap) gives an attacker the one-time code — and a single recovery method is enough to approve signer changes. Prevention lives in the user’s own accounts. Encourage your users to enable:
  • MFA on their email account.
  • A carrier PIN or port-out lock on their phone number.
  • Two-step verification in WhatsApp, if you deliver OTP through WhatsApp.

External Wallet

The key’s safety depends on its holder — whether that is a user’s wallet app or a backend keypair on a server.
  • Never hold an external wallet’s private key on your server. If you need a key your backend operates, use a server signer instead.
  • For client-side integrations, use established, audited web3 wallet providers — a compromised or unvetted provider can get the user to sign a tampered payload.

Quorum Signer

The strongest option when configured correctly — an attacker must compromise threshold members.
  • Do not register a recovery method next to the quorum unless it is held at least as securely as the quorum itself — that method can change signers on its own, without any quorum member.
  • Choose independent members — different people and different signer types. Two members held by one person or one server count as one.
  • Raise the threshold together with the member count. Adding members at the same threshold adds more ways to reach it.

Operational Checklist

  • Evaluate scoped signers. If your backend or an agent signs routine transactions, check whether a scoped signer fits your use case. Scopes limit the tokens, amounts, recipients, and lifetime of a signer, so a leaked key can only move what the scope allows.
  • Monitor wallet activity. Subscribe to webhooks for wallets.transfer.in, wallets.transfer.out, and wallets.signer.exported, and alert on events your application did not initiate. Webhooks do not cover signer or recovery-method changes, or native-token transfers on EVM — cover those by comparing listed signers against your expected configuration and watching native balances through your chain infrastructure or an address-monitoring service.
  • Review registered signers regularly. List the signers on your wallets and remove any that are no longer in use — every leftover signer is a live attack path.
  • Keep an incident contact path. Know how to reach your team, and Crossmint support, before an incident: contact Crossmint.

Protect API Keys

An API key authorizes calls to Crossmint — it is not a signer and cannot approve a wallet action on wallets that hold a separate signer secret. It still deserves protection: a leaked server-side key can read user and wallet data (emails, phone numbers, balances), which is a ready list of targets for a targeted attack. Restrict client-side keys to your authorized origins, and enable only the scopes each key needs.
Signer authority is enforced by the wallet’s contract — a leaked API key cannot sign on wallets with a separate signer secret, though it can expose the user data behind a targeted attack. Keep signer secrets in dedicated storage, keep them off the client, scope what you can, and harden the accounts behind OTP-based signers.

See Also

Signers

Signer types, roles, and recommended configurations

Custody Models

How signer choices map to custodial, non-custodial, and hybrid models

Recovery Methods

How recovery methods restore access and approve signer changes

Restrict a Signer with Scopes

Set spending limits, recipient whitelists, and expiry on signers