Public Route
- Wallet
- Public RPC
- Public Transaction Propagation
- Potential Pre-Inclusion Exposure Intent visible
- Block Inclusion
- Polygon
- Public propagation
- Earlier transaction visibility
- Potentially more exposed execution intent
Powerfully simple Blockchain infrastructure
Send Polygon transactions through a private RPC instead of the public mempool, reducing exposure to frontrunning and sandwich attacks while settlement stays transparent onchain.
01 Rationale
Transactions sent through a public RPC wait in the public mempool, where bots can see them before block inclusion.
Hyperstrate provides a private transaction submission path for Polygon, designed to reduce exposure to frontrunning and sandwich attacks while preserving normal Polygon settlement.
Submit transactions through private infrastructure instead of immediately broadcasting them through the standard public path.
Route transactions through infrastructure designed for fast and efficient delivery.
Transactions ultimately settle normally on Polygon.
02 Comparison
03 Private RPC
A single authenticated JSON-RPC endpoint accepts signed transactions and routes them through private infrastructure toward block production, then reports each state until settlement.
Explore the APIcurl https://rpc.hyperstrate.xyz \
-X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{
"jsonrpc": "2.0",
"method": "eth_sendPrivateTransaction",
"params": ["0x..."],
"id": 1
}'
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"hash": "0x8f3c…a91e",
"status": "settled",
"visibility": "public",
"chain": "polygon"
}
}
04 Use cases
Anything that signs a Polygon transaction can submit it privately, from a single wallet user to a fleet of execution engines.
Private transaction submission for execution-sensitive workflows.
Keep transactions out of the public mempool, where bots watch for trades to front-run or sandwich.
Integrate private transaction routing into automated execution systems.
Submit Polygon transactions programmatically through private RPC infrastructure.
Offer users an optional private transaction mode.
Provide alternative transaction routing.
Integrate private routing into protocol workflows.
Infrastructure suitable for professional transaction systems.
05 Architecture
Swipe sideways to follow the route.
06 Design targets
Figures shown are indicative design targets for illustration only and are not measured production statistics.
07 Developers
const provider = new ethers.JsonRpcProvider(
"https://rpc.hyperstrate.xyz"
);
const wallet = new ethers.Wallet(
process.env.PRIVATE_KEY,
provider
);
const tx = await wallet.sendTransaction({
to: recipient,
value: amount
});
import { createWalletClient, http } from "viem";
import { polygon } from "viem/chains";
const client = createWalletClient({
account,
chain: polygon,
transport: http("https://rpc.hyperstrate.xyz")
});
const hash = await client.sendTransaction({
to: recipient,
value: amount
});
const web3 = new Web3("https://rpc.hyperstrate.xyz");
const signed = await web3.eth.accounts.signTransaction(
{ to: recipient, value: amount, gas: 21000 },
process.env.PRIVATE_KEY
);
const receipt = await web3.eth.sendSignedTransaction(
signed.rawTransaction
);
curl https://rpc.hyperstrate.xyz \
-X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{"jsonrpc":"2.0","method":"eth_sendPrivateTransaction","params":["0x..."],"id":1}'
08 Pricing
You pay per transaction, and only for what happens to it. The more transactions your workspace sends in a month, the less each one costs.
Your first 2,500 transactions each month
Transactions 2,501 to 10,000 each month
Half the Starter price
Transactions 10,001 to 50,000 each month
60% less than Starter
Every transaction after 50,000 each month
70% less than Starter
Each month, your first 2,500 transactions are billed at Starter prices, the next 7,500 at Growth, the next 40,000 at Scale, and the rest at Volume. The count starts again on the 1st of every month (UTC).
Sending more than 250,000 transactions a month? Talk to us about custom pricing
$1,198.50per month, estimated
About $0.100 per transaction
| Tier | Transactions | Cost |
|---|
Transactions that don't land are counted as attempted.
It depends on what happens to it. Using the Starter price as an example:
We hold the full price when you submit, then return whatever isn't used.
09 Questions
Can't find what you need? Talk to our team
Hyperstrate is an independent private transaction provider for Polygon. Instead of broadcasting your transaction to the public mempool, you send it to the Hyperstrate private RPC, which routes it privately toward block production. Once it’s included in a block, it settles on Polygon like any other transaction.
Polygon private transactions are ordinary signed Polygon transactions that are submitted through a private channel instead of being broadcast to the public mempool. While they wait for block inclusion, bots watching the public mempool can’t see them. After inclusion they’re recorded onchain and are as public as any other transaction. Read what private transactions on Polygon are for the full picture.
A Polygon private RPC is a JSON-RPC endpoint that accepts your signed transactions and forwards them through private infrastructure, rather than gossiping them to the public peer-to-peer network. Your wallet, bot or backend talks to it like any other RPC. With Hyperstrate, you point transaction submission at the Hyperstrate endpoint and authenticate with your API key. Learn how a Polygon private RPC works.
A public RPC endpoint forwards your transaction to the public mempool, where node operators and bots can see it before it’s included. A private RPC endpoint forwards it through a private path toward block production instead. A dedicated or paid RPC endpoint isn’t automatically private: what matters is where it sends your transaction. Compare them in public RPC vs private RPC on Polygon.
No. Hyperstrate only changes how a transaction reaches the network. Your transactions settle on Polygon, and nothing about your contracts, tokens or accounts moves anywhere else.
Anyone who sends transactions where timing and intent matter: trading systems, bots, market makers, wallets, DEXs, DeFi protocols and institutional desks.
MEV (maximal extractable value) is profit taken by inserting, reordering or excluding transactions around yours, for example by frontrunning or sandwiching a swap. On Polygon, MEV protection mostly means keeping a transaction out of the public mempool until it’s included, so bots can’t react to it in advance. It reduces exposure but can’t remove every form of MEV, such as back-running after inclusion. Read MEV protection on Polygon.
Your application signs a transaction as usual and sends it to a private RPC endpoint instead of a public one. The private infrastructure forwards it toward block production without broadcasting it to the public mempool. Once it’s included in a block, it settles normally on Polygon, and Hyperstrate reports each state along the way: received, routed, propagated, included and settled. See why private transaction routing matters.
They reduce the most common kind. Frontrunning bots usually spot pending transactions in the public mempool and pay a higher fee to get ahead of them. A privately submitted transaction isn’t in the public mempool, so those bots can’t react to it in advance. Private submission can’t rule out every party that handles a transaction before inclusion, so keep sensible slippage limits as well. Read how to prevent frontrunning on Polygon.
A sandwich attack targets a pending swap. A bot sees it in the public mempool, buys the same token just before it, which pushes the price up, lets your swap execute at the worse price, then sells straight after for a profit. Your slippage tolerance caps how much you can lose. Keeping swaps out of the public mempool and setting tight slippage both reduce the risk. More in sandwich attacks on Polygon.
Yes, once they’re included in a block. Private submission only affects the time between signing and inclusion: while pending, the transaction isn’t in the public mempool, so it generally won’t appear in public pending-transaction views. After inclusion it shows on Polygonscan with its sender, recipient, input data and fees, like any other Polygon transaction. Private submission doesn’t hide transaction details permanently.
Sign the transaction the way you do today, then submit it to a private RPC endpoint instead of a public one. With Hyperstrate, you point transaction submission at the Hyperstrate RPC endpoint and add your API key; your signing code, contracts and wallet stay the same. Reads such as balances and receipts can stay on your usual provider. Step by step: how to send private transactions on Polygon.
Hyperstrate exposes an authenticated JSON-RPC endpoint, so tools that speak Ethereum JSON-RPC can use it, including ethers.js, viem, web3.js and curl. Use the endpoint for sending transactions, authenticate with your API key, and track each transaction until it settles. No smart contract changes are needed. See the developer examples and the guide to Polygon private transaction APIs.
A trading bot signs transactions with its own key and sends them to the Hyperstrate endpoint instead of a public RPC, usually by changing one URL in its configuration. Its orders then stay out of the public mempool while they’re pending, which makes them harder for other bots to copy or frontrun. Bots should still manage nonces, gas fees and slippage carefully, and watch each transaction until it settles.
No. Private routing happens when a transaction is submitted, so contracts don’t need any changes.
Anything that speaks Ethereum JSON-RPC, including ethers.js, viem, web3.js and plain curl. Backend services and trading bots can submit programmatically.
No. Hyperstrate routes your transaction toward block production, but whether and when it’s included is decided by the network. You’re charged less when a transaction is attempted but doesn’t land, and nothing if it’s never attempted.
It depends on how it fails. If a transaction isn’t included, for example because its fee is too low or its nonce has already been used, it never reaches the chain and can be resubmitted. If it’s included but reverts, it’s recorded onchain as failed and the gas it used is still paid, as with any Polygon transaction. For billing, you pay the lower attempted price when a transaction is attempted but doesn’t land, and nothing if it’s never attempted.
If it was attempted but didn’t land, you pay the lower attempted price, $0.050 on Starter. If it was never attempted, you pay nothing.
Every accepted transaction from your workspace counts toward the same monthly total. Your first 2,500 are billed at Starter prices, the next 7,500 at Growth, the next 40,000 at Scale and the rest at Volume. The count starts again on the 1st of each month (UTC).
It keeps the price it was given when it was first accepted and counts once toward your monthly tier, even if the retry happens next month or after your tier changes.
Other chains can have their own prices. If a chain has no published price, paid submission isn’t available on it yet.
10 Insights
Guides to Polygon private transactions, MEV protection and private RPC infrastructure.
All articlesPrivate transactions on Polygon are normal signed transactions that skip the public mempool on their way to a block. Here is how they work, what they protect and where their…
A step-by-step developer tutorial: build and sign a Polygon transaction locally, submit it to a private RPC endpoint, and track it until it is final, with ethers.js, viem and…
What a Polygon private RPC actually does with your transaction, how it differs from a standard RPC endpoint, what it can and cannot hide, and the questions to ask before you…
11 Begin
Protect transaction intent before execution with private transaction infrastructure designed for Polygon.