Check whether the Rift router is serving requests. A successful response is HTTP `200` with the plain-text body `ok`.

Check whether the Rift router is serving requests.

Get system health

Rift is an API for executing anything onchain in 1 click, at the best price, with 0 added fees.

Supported chains and assets

Supported venues

What is Rift?

Rift’s core innovation is a multichain execution engine.

Order Execution

Operational security benefits

Multichain Execution Engine

Let’s talk about use cases of the execution engine. Fundamentally, every use case is just an order outputting a specific asset. Any starting asset can be the input for any use case.

Swaps and Bridging

Payments

Tokenized stocks and RWAs

Vaults

Use Cases

The security model of Rift’s multichain execution engine is fundamentally different from a smart contract on a single chain like Ethereum, although the goal is the same: programmatic executi

Permissionless systems are expensive

Core Dependencies

Cloud Infrastructure

Upgrades and Key Management

Future Improvements

Security Model

## How does integrating Rift make me more money?

How does integrating Rift make me more money?

How do I know I’m getting the best rate when I use Rift?

What’s the difference between Rift and <my favorite aggregator>?

So is Rift competitive with <my favorite aggregator>?

If Rift doesn’t charge fees, how do you make money?

Who has integrated Rift so far?

Does Rift have a referral program?

How much volume has been traded so far on Rift?

What’s the max swap?

What chains and assets are supported?

How do I know Rift is bug-free?

Is Rift a bridge?

Is Rift controlled by a multisig?

Are universal deposit addresses per order or reusable?

Can a partner restrict the API to whitelisted addresses only, so orders only execute for wallets they’ve approved?

Zero fee end to end is true even when the order lands directly in a vault or a tokenized stock, right?

Does Rift support tokenized stocks?

How does the router resolve assets? Is it registered tickers only, or can it take just a contract address?

What’s the failure rate on bridge + swap routes?

What’s Rift’s quote latency (how long /quote takes to come back)?

Does Rift support pre-IPO stocks?

A partner can use Rift as the route and add their own fee on their side, right?

Is Rift the counterparty for trades?

Can I plug into Rift’s OTC protocol?

Is there a real advantage to routing through Rift versus integrating stocks providers directly?

Frequently asked questions

For convenience, popular tokens have dedicated names in Rift's API. This is not an exhaustive list of supported tokens. Tokens outside of this list can be traded by passing the contract addr

Native

Stablecoins

Protocol

Memes

Stocks

Token List

Find the best route between two assets and get a quote that can be used to create an order.

Get a quote

Create an order from a quote and receive a deposit address.

Create an order

Retrieve an order by its id and inspect its current status.

Order statuses

Get order status

Track an order by repeating the order status request with the same id.

Polling an order

Poll an order

The error envelope returned with every non-success status.

One venue's attempt to quote the pair directly.

The venue answered; `quote` is the costed result and `costing_audit`
 the raw answer it was derived from.

The venue did not answer within the `quote_mode` deadline.

Whether this candidate is the quote that was returned.

Milliseconds until the venue answered or was cut off.

The venue's raw answer before execution costs were applied.

Amount the venue said it would return for it.

Turns a quote into an order. Repeating the call with the same `quote_id`
 and the same addresses is safe and returns the order already created;
 changing the addresses is rejected because the quote is already used.

The `id` of a quote from `POST /quote`. The quote must not have
 expired, and a quote binds to one order.

Address on the `from` chain that receives a refund if the order cannot
 be completed. Optional; when not set, the refund goes to the original
 sender.

Address on the `to` chain that receives the output. Validated against
 that chain's address format.

The transfer of the route's output into `to_address`.

Amount of `to` handed to delivery: the last step's `step_amount_out`.

Amount that arrives at `to_address`. This is `estimated_amount_out`.

Cost of the transfer into `to_address`, paid out of `amount_in`.

One venue quote requested for one hop of the search.

The venue answered; `step` is the costed hop.

The venue did not answer within the deadline.

Asset entering the hop, written per `format`.

Position of the hop in the route, counted from zero.

Asset leaving the hop, written per `format`.

A request to price a swap. Amounts and asset names in the request and the
 response are written in `format`.

How amounts and asset names are written in this request and in the
 response. `formatted` writes amounts as decimals in the asset's own
 units and assets as `<chain name>.<symbol>`; `raw` writes amounts as
 base-unit integers and assets in canonical form, `evm:<chain id>.<address>`
 on EVM chains. Defaults to `formatted`. Key on assets with `raw`: symbols
 are presentation and may be reassigned.

Asset to sell, as `<chain>.<asset>`. The chain is a name (`ethereum`,
 `base`, `arbitrum`, `robinhood`, `ink`, `bitcoin`, `hyperliquid`) or
 `evm:<chain id>`. The asset is a symbol, a contract address, or `eth`
 and `btc` for the native coin. Case does not matter.

Amount of `from` to sell. A decimal in the asset's own units when
 `format` is `formatted`, an integer in base units when `raw`.

Include every venue and route that was considered under
 `quote_candidates`. Large, meant for debugging.

`optimal` gives every venue up to 10 seconds to answer, `fast` cuts
 each one off at 1.5 seconds. Defaults to `optimal`.

Include the hop-by-hop `route` in the response.

Asset to receive, in the same form as `from`.

Quote only these venues. Empty means every venue. Cannot be combined
 with `venue_blocklist`.

Never quote these venues. Cannot be combined with `venue_allowlist`.

The graph search for routes through intermediate assets.

Every venue quote requested while walking the paths.

Whether every path was enumerated, false when the search hit its
 limit.

Number of venue steps in the routes tried, the fewest with a path.
 Null when no path exists.

Number of candidate paths found at that hop count.

Each complete path and whether it produced a quote.

Why the search could not start, when it could not.

An order created from a quote, with its deposit address and current
 status.

Amount of `to` delivered to `to_address`. Absent until the order is
 delivered.

Address on the `from` chain to send `from_amount` to.

Instant after which deposits are no longer watched for and the order
 expires. Seven days after creation.

The format every amount and asset name in this response is written in,
 inherited from the quote.

Amount of `from` to deposit, exactly as quoted.

Address on the `from` chain that receives a refund if the order cannot
 be completed. Null when none was given; it is then set to the deposit's
 sender address as soon as the deposit is seen.

`awaiting_deposit` until funds arrive at `deposit_address`; `funded`
 once they are seen; `executing` while the route runs; `delivered` when
 `amount_out` has reached `to_address`; `expired` when nothing arrived
 by `deposit_deadline`; `stalled` when execution gave up and needs an
 operator; `frozen` when a step was halted by policy and needs an
 operator.

Address on the `to` chain that receives the output.

Internal identifier of the vault holding the deposit address.

Venues quoting was restricted to; empty when it was not.

Venues excluded from quoting; empty when none were.

Everything the quoter considered, for debugging. Direct venues under
 `single_hop`, multi-venue routes under `multi_hop`.

The graph search over intermediate assets and its outcome.

One entry per venue asked to quote the pair directly.

Returned when no venue could produce an executable quote for the pair and
 amount.

Every venue and route that was tried, with timings and failures.
 Present only when `include_candidates` was set.

A priced route from `from` to `to`. Valid for order creation until
 `expires_at`, ten minutes after quoting. Amounts and asset names are
 written in `format`.

The final transfer into `to_address` and what it costs.

Expected amount of `to` delivered to the order's `to_address`, after
 every venue and delivery cost.

Instant after which the quote is refused on order creation.

The format every amount and asset name in this response is written in.

Identifier to pass as `quote_id` when creating the order.

Every venue and route considered, with timings and failures. Present
 only when `include_candidates` was set.

The venue steps in execution order. Present only when
 `return_full_route` was set.

The priced route shared by the quote response and every candidate.

One complete path through the graph and its result.

Every hop quoted; `quote` is the costed route.

A hop failed; `error` is what stopped the route.

The assets along the path, from `from` to `to`, written per `format`.

Whether this route is the quote that was returned.

How the step runs: on Bitcoin, on an EVM chain with vault-funded gas,
 on an EVM chain with router-funded gas, or on HyperCore.

Asset entering the step, written per `format`.

Amount entering the step: `from_amount` for the first step, the
 previous step's `step_amount_out` after that.

Amount leaving the step, handed to the next step or to delivery.

Asset leaving the step, written per `format`.

Amount sent to the venue: `step_amount_in` less this step's execution
 cost.

The venue's output for `venue_amount_in`.

Runs on an EVM chain with gas paid by the vault.

Runs on an EVM chain with gas advanced by the router.

Rift Router API

Answers `ok` while the router is serving.

Binds the quote to a fresh deposit address and returns the order. Send `from_amount` of `from` to `deposit_address` before `deposit_deadline`. Presenting the same `quote_id` again returns the same order.

Unknown quote, or `to_address` is not valid for the destination chain

The quote is already bound to another order

Returns the order with its current `status`.

Prices `from_amount` of `from` into `to` across every admitted venue and returns the best route. The quote is stored and can be turned into an order with its `id` until `expires_at`.

Malformed request, unknown asset, or both venue lists set

No venue could quote the pair; candidates are included when `include_candidates` is set

Get system health

Try it out

Request example

Responses