Utila Integration for Firms That Run Stablecoin Wallets on Utila
A Utila integration covers what Utila leaves to payment firms, stablecoin issuers and banks, and Protofire builds it. The integration credits each deposit once, makes payouts safe to retry, answers the co-signer's sign-or-cancel call and posts fees. We deployed Safe on 120+ EVM networks, where it secures $2B+.

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
Your service decides whether each Utila payout signs
For each customer payout, your Utila integration has to answer one question: should the payout sign or cancel? You have chosen Utila for your stablecoin wallets. In webhook mode, Utila's co-signer posts each payout designated to it to the firm's endpoint. A 200 response with signTransaction true signs the payout, and false cancels it (Utila). Utila does not write the firm's endpoint or the ledger entries behind it.
Utila's webhooks tell your service that a transaction changed, and your service has to ask what changed. Each payload contains the vault and a resource name, but not the amount, wallet or direction. Utila discards an event that it has failed to deliver for 24 hours (Utila). Utila's deposit guide leaves the crediting rule to the firm: credit a transaction that is INCOMING and CONFIRMED, and keep crediting idempotent (Utila).
If the firm's side of Utila is left unbuilt, failures are quiet. A customer pays and is not credited. A payout that is resent under a new request ID goes out twice. A payout whose endpoint is down neither signs nor cancels, and it waits (Utila).
Who runs each part of a payment stack on Utila
Utila holds one of the two shares of each vault key, and the firm holds the other. The firm's own services decide when a deposit counts and whether the co-signer signs.
Customer ledger
Signing phones and co-signer server
Vault and policy engine
Key share and API v2
AML screening
Crediting and payout services
Co-signer endpoint
Fee and ledger postings
Four jobs that Utila leaves to your code
Whether a balance is right depends on how the firm's code handles four behaviors that Utila documents.
Crediting deposits from webhook references
The webhook names a transaction, and the receiving service reads it with GetTransaction before acting. Protofire credits each transfer once, on INCOMING and CONFIRMED, because one transaction can contain several transfers. On Stellar, XRP Ledger and TON, Utila does not assign or validate memos. So we map memos to customers and queue the unknown ones. A polling backup catches deposits whose webhook Utila discarded (Utila).
Retrying a payout without paying twice
InitiateTransaction takes a requestId and an externalId. Utila ignores a repeat of a completed request for at least 60 minutes. An externalId must be unique per vault (Utila). Utila's API reference does not say what the repeat returns. After a timeout, Protofire resends the payout with the same requestId and confirms the result with the external_id filter of ListTransactions. A retry after a failure is a new payout with a suffixed externalId. It is sent after the original shows DROPPED or FAILED.
Utila's AML policy allows unmatched transfers by default
A transfer that no AML rule matches is allowed by default (Utila Help Center), so the firm's compliance team adds a catch-all rule. Utila uploads a transfer to the firm's AML vendor first. Utila's AML policy then decides on the result before the transaction policy runs. A transaction rule cannot be edited once it is saved, but it can be duplicated or deleted (Utila Help Center). So each change becomes a new rule in a reviewed order.
Payouts wait while the co-signer endpoint is down
A payout remains pending when the co-signer's endpoint is unreachable, times out or answers with a response other than 200. The co-signer then asks again on its next poll. Utila tells firms to keep the endpoint highly available. Transfers created in the Utila console do not reach the co-signer. Protofire builds the endpoint as a separate service that compares the amount, asset and destination with the order in your ledger. An alert fires when a payout waits longer than the limit that you set.
Utila facts we build against
- Key model
- Two-party MPC between Utila and the customer, each holding one share (Utila).
- Service accounts
- The roles are Viewer, Non-signing operator and Signer. Service accounts use RSA keys, up to 3 active. Adding a key needs admin quorum, and removing a key is immediate. An allowlist of exact IPs is optional (Utila).
- Co-signer
- Runs in the Utila CLI, in "sign all" or webhook mode. An admin approves its device in the console and signs it in the Utila mobile app (Utila).
- Screening
- Chainalysis and Elliptic work in the advanced flow. TRM Labs works in the standard flow, where transfers are uploaded for audit and case management.
- Gas
- EIP-7702 on EVM, fee payer on Solana, Sui and Aptos, Gas Station on TRON. If the Gas Station is empty, the transfer burns TRX from the source wallet. On a wallet's first sponsored EVM transfer, Utila also creates an EIP-7702 delegation transaction (Utila).
This table follows Utila's API reference and Help Center as of November 2026. Protofire integrates Utila for firms that have chosen Utila.
What a Utila integration from Protofire delivers
Deposits credited once, with a backup for lost webhooks
A lost event no longer costs you a support ticket. Protofire builds the webhook receiver and the crediting rule. We also build the memo mapping and the polling backup.
One payout per order
A retry after a timeout reuses the order's identifiers instead of opening a second payout. Protofire builds the payout service to run under a Non-signing operator account.
Co-signer decisions checked against your ledger
The co-signer signs a payout when its amount, asset and destination match the order in your ledger. Protofire builds the co-signer endpoint on your servers.
Numbered rules and held deposits for AML screening
You get a numbered rule list that shows the authority-matrix line behind each rule. Your admins enter the rules, and your quorum approves them. A deposit that Utila's AML policy freezes goes to a held position, and a case opens with the screening result. Protofire builds the held position and the case as in our Chainalysis integration. Sweeps skip the frozen part of a balance.
Fees and balances matched at your cut-off
Network fees are posted per payout, and the EIP-7702 delegation is treated as a separate transaction. Deposits are dated by mineTime, the onchain time, because createTime is when Utila created the record. The match runs at your cut-off, converts Utila's UTC timestamps and flags wallets read before the cut-off.
A recovery test run by your key holders
You get a schedule for wallet data exports, your choice of recovery provider and a written recovery test. Your key holders run the recovery test against the latest export and the recovery package.
Our record: a treasury blueprint and Safe multisig deployments
Utila's admin quorum approves roles and rules before they take effect.A Safe signer set does the same job for onchain funds. Protofire's record here applies to approval by several parties.
A treasury blueprint that names Utila
Protofire's Corporate Crypto Treasury blueprint names Utila among the custody and execution providers that a corporate treasury uses.
Approval by several parties on Safe
Protofire deployed Safe on 120+ EVM networks, where it secures $2B+. The Safe Ecosystem Foundation wrote in May 2026 that Protofire "has been contributing to Safe since 2018". See our Safe multisig work.
Project steps, from vault review to handover
- Step 1
An engineer reads your vault and ledger first
An engineer reads your vault layout and service accounts. The engineer also reads your policy and your target ledger. A written proposal follows. - Step 2
Crediting and the ledger match run read-only
Crediting and the ledger match run under a Viewer account. Utila's deposit guide says a Viewer account is enough for deposit monitoring (Utila). - Step 3
Payouts, rules and the co-signer endpoint come next
Each service gets its own service account. Your engineers generate the account's RSA key, and your admin quorum approves the account's role. Utila allows one account to both start and sign a payout, but Protofire keeps starting and signing in separate accounts. - Step 4
Your team owns and runs the integration
The code, configuration and runbooks are yours. Your key holders have run the recovery test, and your team runs the integration.
How a Utila project with Protofire starts
Work starts when you send your payout and deposit flows and a sample of Utila exports.The first proposal maps each flow to a service account, an event type and a posting rule. The terms below apply to each phase, as set out on how we work.
- Proposal
- In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
- Price
- Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
- Ownership
- Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
- After launch
- Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
- Access
- Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
- Licenses
- Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.
How we work shows a worked proposal.
Three Utila setups with nothing for Protofire to build
- You run one vault with three users and up to 1,000 active wallets, and you start payouts by hand in the console. That setup fits the limits of Utila's Starter plan (Utila).
- You are moving from another MPC provider and keeping the same addresses. Utila's Business Continuity offers "guided setup, policy mirroring and configuration assistance from our onboarding team" (Utila).
- You need accounting data alone. Utila's Cryptio connection imports vault, wallet and transaction data into Cryptio (Utila, October 2026).
Utila keeps one of the two shares of each vault key and runs the API, the webhooks and the screening hooks. Your team keeps the other share, the vault policy and the quorum. Your team also keeps the contract with your AML vendor and your license. Protofire holds no vault admin role, signing key or license. The payout service and the co-signer endpoint run on your servers and act on orders in your ledger. If Protofire runs a service through managed onchain operations under a written scope, that service reads the vault through a Viewer account.
FAQ
What is a Utila integration?
Who can build a Utila integration for a payment firm, stablecoin issuer or bank?
Who releases a deposit that Utila's AML policy froze?
Can a stablecoin issuer or a bank run on Utila?
Does Utila offer a route where a bank's HSM holds the keys?
How does a firm recover or leave a Utila vault?
Can a firm without a license run payouts on Utila?
Get a proposal
Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.
