Skip to main content
Ship on-chain yield and swaps in weeks, not months Deframe is a B2B infrastructure API that enables fintechs, neobanks, wallets, custodians, and exchanges to integrate DeFi yield strategies and cross-chain swaps without building or maintaining an internal blockchain engineering team.

Fast Time-to-Market

Launch DeFi products in weeks instead of months of in-house development

Normalized Data

Get treated, individualized position data across all protocols via one API

Non-Custodial

Your users keep custody — Deframe never touches private keys or funds

​
Who Is Deframe For?

Deframe serves B2B clients building crypto financial products:
  • Fintechs & Neobanks — Offer yield products to end users without building DeFi infrastructure
  • Wallets — Add earn features and cross-chain swaps directly in your wallet interface
  • Custodians — Integrate institutional-grade yield strategies for clients
  • Exchanges — Provide seamless on-chain yield and swap products
  • Investment Platforms — Deploy client funds into curated DeFi strategies
If you’re evaluating whether to build DeFi integrations in-house or use Deframe, this page is for you.

​
What Deframe Abstracts

Building DeFi integrations in-house requires far more than calling a few smart contract functions. Deframe handles the entire complexity stack:
  • Protocol-specific adapters for Aave, Morpho, Lido, Compound, 1inch, Jupiter, and more
  • Transaction bytecode generation for deposits, withdrawals, and swaps
  • Multi-step transaction orchestration (approve → deposit → track)
  • Gas estimation and optimization
  • Transaction simulation and validation
  • Real-time indexing of positions across multiple chains
  • Chain reorganization detection and reconciliation
  • Historical transaction data and realized PnL tracking
  • Accounting-ready data exports
  • Multi-protocol position aggregation
  • Protocol upgrades and versioned migrations
  • New protocol integrations (without requiring client updates)
  • Security audits and monitoring
  • Oracle validation for price feeds
  • Protocol-specific quirks and edge cases
  • RPC node management with automatic failover
  • Job queues and background workers
  • Alerting, monitoring, and incident response
  • Rate limiting and request management
  • Webhook delivery and retry logic
Without Deframe: You need a dedicated blockchain engineering team, ongoing protocol maintenance, and infrastructure ops. With Deframe: You call a few HTTP endpoints and focus on your product.

​
The Integration Experience

Integrating DeFi yield with Deframe follows a simple 3-step pattern:

​
1. Choose a Strategy

Fetch available yield strategies with current APY rates: 
const { data: strategies } = await deframe.get('/strategies')

strategies.docs.forEach(s => {
  console.log(`${s.name} — ${s.apy}% APY on ${s.network}`)
})

​
2. Generate Bytecode

Request ready-to-execute transaction data: 
const { data: result } = await deframe.get('/strategies/aave-usdc-polygon/bytecode', {
  params: {
    action: 'lend',
    amount: '10000000', // 10 USDC
    wallet: userWalletAddress
  }
})

​
3. User Signs & Broadcasts

Your user signs the transaction with their wallet — you keep custody: 
for (const tx of result.bytecode) {
  await wallet.sendTransaction({
    to: tx.to,
    data: tx.data,
    value: tx.value
  })
}
That’s it. Funds are deployed, accruing yield, and tracked automatically.

Quickstart Guide

Build your first integration in 5 minutes

Strategy Deposit Example

Full end-to-end code example

​
Non-Custodial + No Balance-Sheet Risk

Deframe is strictly infrastructure — not a financial product.
Deframe never:
  • Holds your users’ private keys
  • Takes custody of funds
  • Passes funds through our smart contracts
  • Creates balance-sheet risk for your business
Your users:
  • Sign transactions with their own wallets
  • Maintain full custody at all times
  • Interact directly with underlying DeFi protocols
Transaction signing and propagation happen entirely on your side. Deframe provides the data and transaction bytecode — you execute it.

​
Why Not Integrate Protocols Directly?

Many teams start by building direct integrations with protocols like Aave or Morpho. Here’s why that becomes complex fast:

​
Direct Protocol Integration

Requirements:
  • Solidity expertise to understand contract interfaces
  • Protocol-specific adapters for each integration (Aave, Morpho, Lido, Compound, etc.)
  • Indexing infrastructure to track user positions
  • Chain reorg handling and reconciliation
  • Monitoring, alerting, and incident response
  • Ongoing maintenance for protocol upgrades
  • Security audits for every new integration
Time to market: 3-6 months per protocol Team required: 2-3 blockchain engineers + 1 DevOps Ongoing cost: High (maintenance, monitoring, upgrades)

​
Deframe Integration

Requirements:
  • API key
  • Basic HTTP client (axios, fetch, requests)
  • Wallet library for transaction signing (ethers.js, viem)
Time to market: 1-2 weeks for full integration Team required: Any backend engineer Ongoing cost: Low (pay-per-use API fees)
Deframe provides a normalized API surface across all protocols. Add a new protocol without changing your codebase — we handle the complexity.

​
Position Tracking & Data

Beyond transaction generation, Deframe provides real-time position monitoring and accounting-ready data: Available via API:
  • Current position balances across all protocols
  • Realized and unrealized PnL
  • Yield earned over time (with APY breakdowns)
  • Historical transaction data
  • Aggregated portfolio value across chains
  • Webhook notifications for status changes
Example: 
const { data: positions } = await deframe.get(`/wallets/${userAddress}`)

console.log('Total Portfolio Value:', positions.summary.totalUnderlyingBalanceUSD)

positions.positions.forEach(p => {
  console.log(`${p.strategy.name}: $${p.spotPosition.underlyingBalanceUSD}`)
  console.log(`  Current APY: ${(p.spotPosition.apy * 100).toFixed(2)}%`)
})
No need to index events, handle chain reorgs, or reconcile balances — Deframe provides normalized, treated data.

​
FAQ

No. Deframe is non-custodial infrastructure. Your users sign transactions with their own wallets and maintain full custody. Deframe never holds private keys or funds.
No. Deframe abstracts all smart contract interactions. Any backend engineer familiar with REST APIs can integrate Deframe — no blockchain expertise required.
User funds remain safe — they’re deposited directly into underlying protocols (Aave, Morpho, etc.) and are never held by Deframe. Your users can always withdraw directly via protocol UIs.Check our live uptime: Deframe API Status
Yes. Deframe continuously adds new protocol integrations. When we add a new protocol, it becomes immediately available via the API — no client-side changes required.
Yes. Deframe provides testnet endpoints for development and testing. Contact support to enable testnet access for your API key.
Deframe monitors protocol upgrades and handles migrations automatically. Versioned adapters ensure backward compatibility. You’ll be notified of any breaking changes well in advance.

​
Next Steps

Quickstart

Add yield to your app in 5 minutes

Architecture Overview

Understand how Deframe works

API Reference

Explore all available endpoints

Get API Key

Sign up and start building
Questions? Reach out to our team at support@deframe.io