Launching Fynd

Run your own DEX router. Quote swaps in 10ms. Scale it to 1,000 RPS. If you are an Ethereum developer. Run your own local, trustless router.

Go to the quickstart docs and make your first self-routed swap in 5 min.

Why run your own router?

Ten times faster quotes

Quote as many tokens as you want, as often as you want, with instant response. Fynd supports any load.

This changes how you can build in defi:

• Build the fastest DEX trade UI on any chain.
• Sanity-check every third-party quote against your own local quote.
• Evaluate combinatorial paths, e.g. find the best bridge asset in cross-chain swaps.
• Run a trustless price oracle on all tokens.
• Power trading terminals with live spot price and depth updates.
• Add local swap routing to AI agents, without quote-time API dependencies.

How Fynd gets there:

• Nodeless. No node, no RPC overhead. All state pushed to you instantly from Tycho websockets.
• Rust native. Fynd is entirely in Rust, with popular DEXs reimplemented natively, capable of doing 1 million pool simulations per second in a single thread (0.9 microseconds/simulation).
• Auto-indexing. New pools and tokens are live on your local router within seconds.
• No external calls. No RPC/APIs at runtime. Everything resolves locally.

Benchmark Data

On a laptop you get ~700 RPS with sub-100ms P99. On a server, throughput scales past 1,200 RPS with sub-50ms P99. Throughput scales near-linearly with cores.‍

Approximate cost: MacBook: free. AWS c7a.8xlarge on-demand ~$1,200 per month, spot ~$150 per month. Hetzner AX162 (48 cores, AMD EPYC) ~$200 per month.

Run the benchmark yourself: docs.fynd.xyz/guides/benchmarking

Fynd is not just fast, from the start Fynd comes with all defi liquidity built in.

Settle over all of DeFi

Through Tycho (which handles $2B/month in volume and routes 30% of CowSwap trades), Fynd routes you over 27 protocols, 6.5M+ pools, and 5.8M+ tokens across Ethereum, Base, and Unichain.

New DEXs, new hooks, and new market makers integrate with Tycho even before their launch, and you can route on it from launch with Fynd.

When a new token, pool, or hook deploys, Fynd routes through it within seconds.

But you can do more than just route. You can now build the router that you want.

Own and trust your router

Fynd is modular, self-contained, fast, and extensible. Easy to customize and build the router you want.

For example, you can optimise it to:

• Settle more reliably: Restrict to safe tokens, safe pools, specific DEXs, or RFQ quotes only.
• Find better routes: Search deeper with multiple solving algorithms.
• Trust your quotes: Fynd uses exact state and verified implementations of onchain DEX logic. Quotes are precise, not approximations.
• Focus on specific pools: Build a custom router and frontend for your DEX, your tokens, or your hook.
• Trade on the long tail: Index the newest pools and tokens. Offer trades on assets that aggregator APIs don't cover yet.
• Set your own fee rules: Monetize your swaps. Charge fees, give discounts, or set custom fees on every swap.

We made it as easy to get started, from any stack.

Make your first trade in 5 minutes

Prerequisites: Rust 1.92+ and a Tycho API key (free, from @fynd_portal_bot on Telegram).

Clone Fynd, set your API key, and start the server:

git clone https://github.com/propeller-heads/fynd.git
cd fynd
export TYCHO_API_KEY=your-api-key
cargo run --release -- serve

‍

Query your local router:

curl -X POST http://localhost:3000/v1/quote \
  -H "Content-Type: application/json" \
  -d '{
    "orders": [{
      "token_in": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "token_out": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
      "amount": "1000000000",
      "side": "sell",
      "sender": "0x0000000000000000000000000000000000000001"
    }],
    "options": {
      "timeout_ms": 5000,
      "min_responses": 1
    }
  }'

‍

You now have your own routing API. 100% local, no rate limits, fully customizable.

Full quickstart: docs.fynd.xyz/quickstart

Integrate anywhere

Fynd runs as a local HTTP server or embeds directly as a Rust crate (no HTTP overhead, no sidecar). Any language or framework can call it. For deeper integration, use the native client SDKs:

• TypeScript (clients/typescript): Quote, sign with Permit2, and execute swaps on-chain from any Node or browser app.
• Rust (clients/rust): Embed quoting and execution directly in your Rust application. No HTTP overhead.

Both clients handle Permit2 signing and on-chain settlement. Or call the REST API from Python, Go, or your favorite stack.

What's next

Coming soon:

• Split routes: Optimize across multiple paths.
• Revert protection: Your trade always goes through.
• More chains: Arbitrum, BSC, and Polygon.

Follow @PropellerSwap for updates.

Links

• Docs: docs.fynd.xyz
• GitHub: github.com/propeller-heads/fynd
• Free API key: @fynd_portal_bot on Telegram
• Talk to our team: t.me/tanay_j
• Community: tycho.build on Telegram