Stripe’s Tempo blockchain transaction types (Use cases and benefits)

Tempo began as a joint blockchain initiative incubated by Stripe and Paradigm in 2025, born from a shared belief that existing blockchains were not yet optimized for real-world payments at scale.
Rather than relying on general-purpose networks originally built for trading and decentralized finance, Stripe and Paradigm set out to create a purpose-built Layer-1 blockchain for stablecoins and payments.
In early Q1 of 2026, they’re preparing to launch Tempo’s mainnet.
Alongside the chain itself, Tempo introduces Tempo Transactions, a set of native transaction types designed to reduce friction across payment flows, wallet UX, and application development.
Rather than layering payment features on top of general-purpose smart contracts, Tempo builds them directly into the transaction layer. This design choice reflects a core thesis: payments infrastructure should be optimized for throughput, predictability, and operational simplicity.
At its core, Tempo is a Layer-1 blockchain purpose-built for moving money. It is not designed for NFTs, generalized DeFi primitives, or arbitrarily complex contracts. Instead, it focuses on high-volume, low-latency, programmable payments that resemble modern financial rails more than traditional blockchains.
Tempo Transactions are the mechanism that makes this possible.
What are Tempo Transactions?
Tempo Transactions extend Ethereum’s transaction model by introducing first-class, payment-native behaviors directly into the protocol.
Rather than requiring developers to deploy, audit, and operate custom smart contracts or rely on off-chain relayers, Tempo encodes common payment behaviors directly into transaction types. These behaviors include batching, fee sponsorship, concurrency, scheduling, and modern authentication.
From a developer’s perspective, Tempo Transactions behave like normal EVM transactions, but with additional structured fields that unlock these capabilities by default.
Why Tempo Transactions?
Most blockchains inherit Ethereum’s original transaction assumptions: One sender, one nonce, one fee payer, one action, immediate execution.
Those assumptions work well for simple transfers, but they break down quickly in real payment systems. Payroll, merchant settlement, subscriptions, refunds, and sponsored user actions all require additional infrastructure.
Tempo Transactions address this gap by:
- Building on EIP-2718 typed transactions
- Reducing operational overhead for payment applications
- Making payment behaviors auditable, deterministic, and protocol-enforced
Developers no longer need to recreate payment infrastructure at the application layer. The chain provides it natively.
Key features of Tempo Transactions
Tempo Transactions emphasize scalability, usability, and payment-specific optimizations. The core features are outlined below.
Batched transactions
Tempo supports batched transactions, allowing a single transaction to include thousands of individual operations.
Examples include:
- Payroll disbursements
- Merchant settlement runs
- Refund batches
- Mass payouts
All operations within the batch either succeed together or fail together. There is no partial execution. This guarantees consistency for high-volume payment flows and removes the need to track per-transfer success states.
Concurrent execution
Traditional Ethereum accounts serialize execution using a single nonce. This creates bottlenecks when an account needs to submit many transactions concurrently.
Tempo introduces a nonceKey mechanism that allows multiple independent transaction streams from the same account. This enables parallel execution without nonce collisions.
For payment processors and platforms, this means:
- Higher throughput per account
- No artificial sequencing constraints
- Better alignment with real-world payment concurrency
Fee sponsorship and gas abstraction
Tempo Transactions natively support separate fee payers.
An application, platform, or sponsor can pay transaction fees on behalf of users. End users do not need to hold native gas tokens or manage balances just to transact.
This removes one of the largest UX barriers in crypto payments and allows Tempo applications to feel more like traditional fintech products.
Scheduled transactions
Tempo Transactions can specify execution windows that tell validators exactly when a transaction is allowed to be included in a block. Validators will only process the transaction once it falls within that permitted time range.
This enables:
- Recurring subscriptions
- Delayed settlements
- Time-locked payouts
All without external schedulers or bots. Scheduling is enforced at the protocol level.
Modern authentication with passkeys
Tempo supports WebAuthn and P256 signatures as authentication mechanisms. Tempo allows passkey public keys to be registered directly onchain as access keys for an account.
This allows users to sign transactions using passkeys on their devices.
In this model, the wallet no longer acts as custodian of private keys. Instead it functions as a transaction orchestrator and user interface, responsible for constructing transactions, applying policy constraints, and requesting user authorization.
Benefits and real-world use cases
By moving payment logic into the transaction layer, Tempo reduces overall infrastructure complexity by eliminating the need for layered middleware and auxiliary smart contracts. This design means there are fewer contracts to audit and maintain, which directly lowers the surface area for security reviews and long-term maintenance.
With less offchain coordination and fewer moving parts, operational risk is reduced, particularly as systems scale. At the same time, embedding this logic at the transaction level enables higher throughput at scale, allowing large volumes of payments to be executed more efficiently and predictably.
Common use cases include:
Fintech and commerce: Sponsored fees and stablecoin gas enable seamless checkout experiences without exposing users to crypto mechanics.
Enterprise payroll: Atomic batching allows large disbursement runs with deterministic execution and simplified reconciliation.
Subscriptions and billing: Scheduled transactions remove reliance on off-chain automation and reduce failure modes.
Cross-border settlements: Stablecoin-native transactions with sponsored fees reduce friction for international transfers, allowing businesses to move funds across jurisdictions without exposing end users to network fees, wallet management, or chain-specific complexity.
Benefits of using Turnkey with Tempo
Tempo provides powerful transaction primitives, but those primitives still require secure key management and policy enforcement.
Turnkey provides wallet infrastructure built around isolated signing environments, fine-grained policies, and auditable execution. When combined with Tempo, it enables payment systems that are both highly programmable and operationally safe.
Using Turnkey alongside Tempo allows teams to:
- Secure private keys inside isolated execution environments
- Enforce signing policies for batching, limits, and destinations on Ethereum legacy transactions, with limited policy support on Tempo Transactions
- Support passkeys, programmatic signers, and server-side automation
- Deliver consistent security guarantees across high-throughput flows
Tempo handles what a transaction can do. Turnkey governs when and how it is allowed to be signed.
Tempo x Turnkey: advanced wallets for a payment-first blockchain
Tempo represents a shift in how blockchains approach payments. Instead of retrofitting financial workflows onto generalized execution environments, it builds payment behavior directly into transactions.
When paired with Turnkey’s policy-driven wallet infrastructure, Tempo Transactions become safer, more predictable, and easier to operate at scale.
For teams building the next generation of payment rails, this combination offers a path toward blockchain systems that feel less experimental and more like real financial infrastructure.
Related articles
.png)
Life after Bybit: Takeaways from the biggest hacks in crypto history
The biggest crypto hacks of the last decade: What happened, why it happened, and what that can teach us about building secure systems in the future.
.png)
Web3 security: Implicit trust, dependencies, and verifiability
Learn how verifiable systems allow participants to confirm that infrastructure is operating correctly by making system behaviors observable rather than assumed.
