Micropayments enable creators to monetize directly. Instead of relying on ads or subscriptions, users pay exactly what content is worth to them...
{/* Rest of article content */}writes key 0x00...00"] --> S0["Shard 0"] B["Transaction B:
writes key 0x55...55"] --> S1["Shard 1"] C["Transaction C:
writes key 0x56...00"] --> S1 end ``` ### System architecture Radius is based on [PArSEC](https://dci.mit.edu/s/p.pdf) (Parallel Sharded Transactions with Contracts). ```mermaid flowchart TB App["Application"] -->|JSON-RPC| FE FE["Agent Frontend
Rate limiting, pre-execution"] --> BE BE["Agent Backend
Transaction execution, batching"] --> S0 & S1 & S2 & SN S0["Shard 0"] S1["Shard 1"] S2["Shard 2"] SN["Shard N"] ``` ### Why Radius does not use blocks for execution Radius optimizes for payment throughput and low latency. It executes transactions as the atomic unit instead of batching transactions into globally ordered blocks. This removes global block-consensus overhead and enables shard-local replication with Raft. | Aspect | Blockchains | Radius | | ----------- | -------------------------------------- | -------------------------------------- | | Consensus | Global (all nodes agree on each block) | Per-shard (Raft replication) | | Ordering | Sequential block ordering | Parallel across independent shards | | Propagation | Broadcast blocks network-wide | Route writes directly to target shards | | Finality | Probabilistic (confirmations) | Deterministic after one Raft commit | ### Congestion control for hot keys When many transactions target the same key, Radius batches conflicting transactions to reduce lock churn. 1. **Detect:** Shards identify high-conflict keys. 2. **Route:** Frontend sends conflicting traffic to one backend. 3. **Batch:** Backend executes the batch sequentially under one lock. 4. **Release:** Lock is released after ordered execution completes. ```mermaid flowchart LR subgraph Without["Without batching"] direction TB T1["Tx1"] --> Lock1["Lock X"] T2["Tx2"] --> Lock1 T3["Tx3"] --> Lock1 Lock1 -->|"conflicts"| X1["β"] end subgraph With["With batching"] direction TB Batch["Batch: Tx1, Tx2, Tx3"] -->|"single lock"| Lock2["Lock X"] Lock2 -->|"execute sequentially"| OK["β No conflicts"] end ``` ### Live metrics Track real-time performance on Radius network dashboard. ### Next steps - [Designed for the Internet of Tomorrow](/differentiators/designed-for-internet-of-tomorrow.md) β EVM compatibility and behavior differences - [JSON-RPC API](/developer-resources/json-rpc-api.md) β Method-level reference - [Claim and transact](/get-started/claim-and-transact.md) β Go from zero to your first transaction --- ## Designed for the internet of tomorrow *EVM-compatible infrastructure with payment-first economics* Radius gives you Ethereum-compatible development patterns with payment-first economics optimized for real-world transaction volume. ### What works out of the box Most Ethereum development workflows transfer directly to Radius. | Tool | Status | | ------------------------ | -------------------------------------------- | | **Solidity** | Fully supported (validated up to Prague) | | **WAGMI** | Compatible | | **viem** | Compatible | | **OpenZeppelin** | Compatible | | **Foundry** | Compatible | | **Standard precompiles** | Compatible (validated up to Prague) | ### What differs from Ethereum Radius is EVM compatible, but it makes deliberate tradeoffs for payment workloads. #### Use fixed, predictable fees Ethereum fees change with demand. Radius uses fixed gas pricing so costs remain predictable. | Ethereum | Radius | | ------------------------ | ---------------------------------- | | Fee market bidding | Fixed gas pricing | | `eth_gasPrice` varies | `eth_gasPrice` returns 9.85998816e-10 | | Cost planning is dynamic | Cost planning is deterministic | A standard transaction cost is about 0.00010 USD. #### Settle in milliseconds | Ethereum | Radius | | ----------------------------- | ---------------------------- | | Confirmation-based confidence | Immediate finality | | Reorg risk exists | No reorg model | | Minutes to high confidence | Millisecond-scale settlement | #### Use stablecoin-native fee flow | Ethereum | Radius | | ------------------------------ | --------------------------------------- | | Must hold ETH for fees | Fees paid in RUSD | | Separate gas-asset requirement | Stablecoin-native flow for payment apps | | Volatile fee asset | Stable-value fee model | ### Contract implications #### Keep standard Solidity patterns Your existing contract logic and ERC standards work as expected. ```solidity IERC20(token).transfer(recipient, amount); mapping(address => uint256) balances; balances[msg.sender] = 100; emit Transfer(from, to, amount); ``` #### Avoid assumptions tied to Ethereum-native balance semantics Prefer explicit token accounting over patterns that assume ETH-style native balance behavior inside contract logic. ```solidity // Prefer token-based accounting checks in payment flows. require(IERC20(feeToken).balanceOf(address(this)) > 0); ``` ### Data integrity model Radius prioritizes deterministic execution and replicated operation: - Three-node clusters provide fault tolerance - Replication preserves data durability - Deterministic execution preserves consistency This model is designed for high-throughput payment infrastructure. ### Why this matters for modern applications #### AI and machine-to-machine payments Autonomous systems need low-latency settlement for API calls, inference, and compute usage. Radius supports this with: - Instant settlement - Sub-cent transaction costs - Stable-value fee economics #### Micropayment business models Low predictable cost unlocks: - Per-request API billing - Pay-per-visit content - Streaming payments for compute and bandwidth ### EIP support Radius tracks Prague support through Revm 33.1.0. | EIP | Support | | -------- | ------------------------------------------ | | EIP-7702 | Supported | | EIP-1559 | Supported (adapted to fixed-fee economics) | | EIP-2930 | Supported | | EIP-4844 | Supported | ### Precompiles | Address range | Precompile set | | --------------- | ----------------------------- | | `0x01` - `0x0a` | Standard Ethereum precompiles | | `0x4Db27Fa...` | Radius Edge extensions | | `0x07a2bA2...` | Debug utilities | ### Network configuration | Parameter | Value | | --------------- | ------------------ | | Network Name | Radius Testnet | | RPC URL | https://rpc.testnet.radiustech.xyz | | Chain ID | 72344 | | Currency Symbol | RUSD | ### Next steps - [Ethereum compatibility](/developer-resources/ethereum-compatibility.md) β Behavior differences and RPC constraints that affect production systems - [Network and RPC](/developer-resources/network-configuration.md) β Endpoints, chain IDs, and integration setup - [Fees](/developer-resources/fees.md) β Fee model and the Turnstile behavior --- ## Pay-per-Visit Content *Enable micropayment-based content access. Users pay cents per page view instead of monthly subscriptions or ad-supported tiers.* This use case shows how to monetize premium content with per-visit micropayments instead of subscriptions or ad-driven models. ### Problem statement Traditional content monetization forces creators into difficult trade-offs: - **Subscriptions** force users to pay for content they don't consume. Most readers abandon paywalls rather than commit to a monthly subscription for a single article, leaving the content provider with a missed connection with a potential user. - **Ads** damage user experience, raise privacy concerns, and are increasingly under strain with the rise of web crawlers. - **Freemium models** leave money on the table from engaged users willing to pay for premium content. Radius solves this with pay-per-visit micropaymentsβusers pay exactly for what they read, watch, or download. No subscriptions. No trackers. Instant access. ### How it works The user journey is frictionless: 1. **User lands on premium content** and sees a paywall 2. **Clicks "Unlock" and chooses a micropayment amount** (0.05 USD, 0.10 USD, 0.25 USD, etc.) 3. **Confirms payment in their wallet** (MetaMask, Rainbow, etc.) 4. **Content unlocks instantly** after payment confirmationβno waiting, no email verification 5. **Payment settles instantly** to your account in stablecoins Behind the scenes, Radius handles the heavy lifting: gas fees are paid in stablecoins via the Turnstile, transactions settle in seconds, and there's no intermediary taking a cut. > **βΉοΈ Info:** Radius processes transactions with instant finality. Users see content appear immediately after they confirm paymentβno "waiting for confirmation" screens. ### Implementation example Here's a complete React component that implements a content paywall with Radius micropayments: #### Step 1: Paywall component ```typescript import { useState } from 'react'; import { parseEther } from 'viem'; import { useAccount, useWriteContract, useWaitForTransactionReceipt } from 'wagmi'; interface ContentPaywallProps { contentId: string; title: string; amount: string; // e.g., "0.10" (USD) children: React.ReactNode; } export function ContentPaywall({ contentId, title, amount, children, }: ContentPaywallProps) { const { address, isConnected } = useAccount(); const [isUnlocked, setIsUnlocked] = useState(false); const [isPaying, setIsPaying] = useState(false); const { data: hash, writeContract, isPending } = useWriteContract(); const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash, }); const handleUnlock = async () => { if (!address) return; setIsPaying(true); try { // Send payment to content owner address const contentOwner = '0x742d35Cc6634C0532925a3b844Bc9e7595f7E9F1'; writeContract({ to: contentOwner, account: address, value: parseEther(amount), }); } catch (error) { console.error('Payment failed:', error); setIsPaying(false); } }; // Once payment is confirmed, unlock content if (isSuccess && !isUnlocked) { setIsUnlocked(true); setIsPaying(false); } if (!isConnected) { return (
{title}
Connect your wallet to unlock this content.
{children}
;
}
return (
{title}
This premium content costs {amount} USD to unlock.
One-time payment. No subscription. Instant access.
{isPending &&Awaiting wallet confirmation...
} {isConfirming &&Confirming payment...
} {hash && (Transaction: {hash.slice(0, 10)}...{hash.slice(-8)}
)}
{[
{ id: '1', title: 'Breaking News', type: 'article' },
{ id: '2', title: 'Tutorial: Radius SDK', type: 'video' },
{ id: '3', title: 'Stablecoin Economics', type: 'research' },
].map((item) => (
))}
);
}
```
### Benefits of Radius micropayments
#### For users
- **Lower barrier than subscriptions** β Pay 0.01 USD for one article instead of 15.00 USD/month
- **No tracking required** β Stablecoins provide value; ads and trackers don't
- **Global access** β Pay with Radius in any country; instant settlement
- **Instant access** β Content unlocks immediately after payment confirmation
#### For creators
- **Broader viewership** β Every engaged reader becomes a paying user
- **No chargeback risk** β Stablecoin transactions are final; no refund disputes
- **Direct payment** β Money goes directly to you; no subscription platform taking 30%
- **Flexible pricing** β Set different prices for articles, videos, researchβwhatever works for your audience
#### For both
- **No intermediaries** β Direct creator-to-reader transactions
- **Instant settlement** β Money available immediately, not locked up for 30 days
- **Low transaction cost** β Radius handles gas via the Turnstile; you pay almost nothing per transaction
- **Works globally** β Stablecoins work in any country; currency conversion handled on-chain
### Use cases
Micropayments work for any content creators want compensation for:
- **News & Journalism** β Articles, investigations, breaking news
- **Video Content** β Tutorials, documentaries, educational videos
- **Research & Data** β Academic papers, market research, whitepapers
- **Premium Tutorials** β In-depth guides, programming courses, design resources
- **Podcasts** β Individual episode access or full-library unlock
- **Photography & Art** β High-resolution downloads, exclusive collections
- **Gaming Content** β Cosmetics, level packs, exclusive streams
- **Expert Advice** β Consultations, AMA sessions, email support tiers
### Best practices
1. **Show the price upfront** β Users hate surprises. Display the cost before they click "unlock"
2. **Make wallet connection obvious** β If not connected, guide users to connect before payment
3. **Handle network errors gracefully** β Show retry buttons if payment fails
4. **Store payment receipts** β Keep transaction hashes for support and analytics
5. **Offer value for the price** β 0.10 USD articles should be substantial; avoid paywalling single paragraphs
6. **Test on testnet first** β Always verify payment flow before production
7. **Monitor gas costs** β Radius fees are low, but still track transaction costs
### Scaling considerations
- **Batch settlements** β Collect multiple payments, settle once daily to save costs
- **Tiered content** β Use content length/quality to justify different price points
- **Bundle offers** β Sell article packs ("10 articles for 0.50 USD") to increase AOV
- **Incentivize loyalty** β Offer discounts to frequent readers or newsletter subscribers
- **Track conversion** β Monitor which price points convert best for different content types
> **βΉοΈ Info:** Radius transactions cost nearly nothing to process. A 0.10 USD article payment costs less than 0.01 USD in fees, so almost all revenue goes to the creator.
### What's next
**Ready to monetize?** Build your first paywall, test on testnet, and start earning from every engaged reader.
---
## Real-time API metering
*Charge per API call with instant on-chain settlement*
Use this guide to implement per-request billing with instant settlement on Radius.
### Problem statement
Conventional API billing relies on monthly invoices processed with credit card rails. In practice, this means API providers are extending credit for services rendered for 30+ days while also paying 2.9% + 0.30 USD in transaction fees. For agents procuring services in real-time for sporadic, bursty workloads, this model is insufficient.
Radius solves this with real-time, per-request billing. Each API call includes payment that settles instantly. No credit card fees. No counterparty risk. No intermediaries.
### How it works
When a client calls your API:
1. **Client sends payment proof** β The client constructs a microtransaction on Radius and includes proof in the API request
2. **Server verifies payment** β Your API server verifies the payment on Radius in milliseconds
3. **Request executes** β If payment is valid, your API processes the request
4. **Instant settlement** β The payment is finalized within seconds, and you control the tokens immediately
Total latency: sub-second verification + your API response time. No batch processes. No waiting for settlement.
### Benefits over traditional API billing
| Feature | Traditional | Radius |
| ----------------------- | ------------------------ | --------------------- |
| **Payment fees** | 2.9% + 0.30 USD | 0.00010 USD per transfer |
| **Settlement time** | 30+ days | Seconds |
| **Chargebacks** | Common, costly | Impossible (on-chain) |
| **Global access** | Credit card required | Wallet + USD only |
| **Minimum transaction** | 5β10 USD | 0.00010 USD |
| **Revenue control** | Intermediary takes a cut | You control 100% |
### Use cases
#### AI/ML APIs
Charge per inference or per token. Users pay only for what they use, instantly:
```typescript
const costPerToken = parseEther('0.000001'); // Per token charged
const tokensGenerated = 150;
const totalCost = BigInt(tokensGenerated) * costPerToken;
// Client pays before using the API
const hash = await walletClient.sendTransaction({
to: apiServer,
value: totalCost,
});
```
#### Premium data feeds
Real-time stock prices, weather data, sports statsβcharge per request:
```typescript
app.post('/api/stock-price', async (req, res) => {
const { symbol, paymentHash } = req.body;
// Verify payment for premium data
const payer = await verifyPayment(paymentHash, PREMIUM_DATA_COST, serverAccount.address);
if (!payer) {
return res.status(402).json({ error: 'Payment required' });
}
// Return premium stock price data
res.json({ symbol, price: 123.45, timestamp: Date.now() });
});
```
#### Content APIs
Charge for access to paywalled articles, ebooks, or videos:
```typescript
// Client pays for each piece of content
const contentId = '123-article-slug';
const hash = await walletClient.sendTransaction({
to: publisherAddress,
value: ARTICLE_COST,
});
// Request with proof of payment
const content = await fetch('/api/articles/' + contentId, {
headers: { 'X-Payment-Hash': hash },
});
```
### Best practices
- **Show pricing upfront** β Let users know the cost before sending payment
- **Batch requests** β Allow clients to send multiple queries in one payment
- **Discounts for volume** β Offer lower per-request costs for bulk prepayment
- **Error handling** β Handle failed payments gracefully; return 402 Payment Required
- **Monitoring** β Track payment success rates and processing times
### FAQ
**How long does payment verification take?**
Sub-second. Radius achieves near-instant finality, so payment verification completes in milliseconds.
**Can clients batch multiple requests into one payment?**
Yes. You can structure pricing around request batches or data volume rather than individual calls.
**What if a payment transaction fails?**
The transaction fails on-chain with no side effects. Your API returns 402 Payment Required, and the client can retry.
**Do I need a smart contract?**
No. Native token transfers work perfectly. Only use smart contracts if you need complex payment logic (for example, split payments, conditional refunds).
**Can I refund payments?**
Yes, by sending tokens back to the client. You control the server wallet and can execute refund transactions directly.
**How do I handle pricing changes?**
Update your server code and redeploy. Clients see the new pricing immediately. Consider a grace period for old prices.
### Next steps
- **[Quick Start](/get-started/claim-and-transact.md)** β Send your first transaction on Radius
---
## Streaming Payments
*Enable continuous, per-second billing for compute, bandwidth, and content delivery.*
Use streaming payments on Radius to charge continuously based on real usage, with instant settlement and predictable costs.
### Problem statement
Traditional billing models create friction for both service providers and consumers:
- **Upfront payment risk**: Users pre-pay without knowing exact consumption, risking overpayment and fund lockup
- **Invoice-based delays**: Providers wait days or weeks to get paid, exposing themselves to default risk
- **Coarse billing granularity**: Services charge by month or hour, forcing users to pay for unused capacity
Radius solves this with **continuous micropayments**βpay-as-you-consume settlement at second-level granularity, eliminating both payment and credit risk entirely.
### How it works
Streaming payments establish an ongoing payment loop between client and server:
1. **Client initiates a session** with the server, providing an account with available funds
2. **Payments flow at regular intervals** (every second, every minute) based on service consumption
3. **Service continues uninterrupted** as long as payments arrive on schedule
4. **Either party can terminate** anytimeβthe client stops payments, or the server stops service
This creates a natural "circuit breaker": if the client runs out of funds or the server detects payment failure, service halts immediately.
### Benefits
Streaming payments unlock several key advantages:
| Benefit | Impact |
| ----------------------- | ----------------------------------------------------- |
| **No overpayment** | Pay only for what you consume, down to the second |
| **No credit risk** | Real-time settlement eliminates provider default risk |
| **Granular billing** | Per-second pricing enables precise cost-matching |
| **Instant termination** | Service stops immediately on payment failure |
| **Predictable costs** | Linear per-unit pricing with no hidden fees |
| **Improved UX** | Users pay gradually instead of upfront |
### Use cases
Streaming payments are ideal for:
#### Cloud compute
**Pay-per-second VMs and container instances**
- Traditional: Monthly subscriptions for over-provisioned capacity
- Streaming: Micro-VM charges by the second, scale up/down instantly
- Example: 0.01 USD per second per vCPU
#### Video/content streaming
**Pay-per-minute or per-gigabyte**
- Traditional: Tiered monthly plans with bandwidth caps
- Streaming: Continuous payment as bytes flow, no caps or surprises
- Example: 0.01 USD per MB of video data
#### WiFi and network access
**Pay-per-minute connectivity**
- Traditional: 24-hour passes or monthly contracts
- Streaming: Micropayments per minute of active connection
- Example: 0.01 USD per minute of active connection
#### AI inference and APIs
**Pay-per-token or per-request**
- Traditional: Throttled APIs with prepaid tokens
- Streaming: Continuous settlement as tokens are generated
- Example: 0.01 USD per 1,000 tokens generated
### Network configuration
**Radius Testnet:**
- RPC Endpoint: https://rpc.testnet.radiustech.xyz
- Chain ID: 72344
- Native Token: RUSD
- Block time: ~2-3 seconds
> **βΉοΈ Info:** Testnet is perfect for experimenting with streaming payment patterns. Get free RUSD tokens from the [Radius Testnet Faucet](https://testnet.radiustech.xyz
> /wallet).
### What's next?
Learn more about building on Radius:
- **[Quick Start - First Payment](/get-started/claim-and-transact.md)** β Send your first transaction
---
---
## Dashboard overview
*Accounts, fees, and RPC key management*
> **π Note:** **Token names used on this page:**
>
> - **RUSD** is the native token and fee token on Radius.
> - **SBC** is an ERC-20 stablecoin used for transfers.
> - If an account has SBC but not enough RUSD for gas, the Turnstile can convert SBC to RUSD inline.
> :::
>
> The Radius Dashboard is the primary app for interacting with Radius. Use it to claim SBC, send transactions, bridge assets, manage RPC API keys, and explore network activity.
>
> Content for {item.title}
>
> ## Understand account environments
>
> Accounts on Radius Network and Radius Testnet are separate.
>
> If you use both environments, create one account per environment.
>
> 
>
> :::note
> Switch environments with the selector at the top of the Dashboard.
### Find fee data in the app
Use these screens to check fees:
1. **Network Activity**: The **Stablecoin Transfer Cost** metric shows the average cost of a standard stablecoin transfer.
2. **Transaction Details**: The **Fee** field shows the fee charged for that transaction.
#### Compare transaction details by transfer type
Transaction details differ by transfer type:
- **ERC-20 transfer** (for example, SBC): shows contract interaction rows and token transfer rows.
- **RUSD transfer**: usually shows one native transfer row.
Both views include the fee, but the operation breakdown is different.
##### ERC-20 transfer example
##### RUSD transfer example
> **βΉοΈ Info:** **Stablecoin Transfer Cost** is an average reference value for standard transfers. Actual fees depend on gas used.
Read more in [Fees](/developer-resources/fees.md).
### Manage RPC API keys
Create RPC API keys in the Dashboard.
Each Dashboard account supports up to five API keys.
For usage details, see [Network and RPC](/developer-resources/network-configuration.md#rate-limiting--api-keys).
### EIP-3091 explorer link support
The Dashboard supports [EIP-3091](https://eips.ethereum.org/EIPS/eip-3091) URL patterns for explorer deep links. It uses standard routes such as `/tx/{hash}`, `/address/{address}`, and `/token/{address}` so wallets and apps can generate links without custom mapping.
> **π Note:** Radius handles blocks differently from Ethereum. Read [Ethereum compatibility](/developer-resources/ethereum-compatibility.md#blocks) for details.
---
## Radius Network
*Build on stablecoin-native infrastructure*
Use this guide to learn how Radius works and move from first transaction to production integration.
> **βΉοΈ Info:** Building with LLMs? Check out these skills.
>
> -
> Radius Dev: Use to build dapps and launch projects
>
>
> -
> Dripping Faucet: Use to fund testnet and mainnet wallets to easily get started
>
### Welcome
Radius is a high-performance settlement engine for machine-to-machine payments. It is EVM compatible, settles in sub-second time, and uses predictable stablecoin-native fees.
Use these docs to get from first transaction to production integration.