DeFi Protocols Explained: Types, How They Work, and Risks

A DeFi protocol is the on-chain logic that moves money without a bank in the loop. DeFi, short for decentralized finance, is financial services rebuilt as open software on a blockchain, and a DeFi protocol is the individual building block that does one financial job: lending, trading, issuing a stablecoin, staking, and so on. Strip away the marketing and a DeFi protocol is a set of smart contracts that holds funds, enforces rules, and settles transactions automatically. Understanding the main types of DeFi protocols is the difference between integrating a building block that fits your product and inheriting someone else's risk by accident.

This is a taxonomy, not a tutorial. We'll walk through the categories that matter in production, how each one works under the hood, how much value they hold, a named list of the largest protocols in each category with the date it was measured, and the trade-offs you weigh before you pick one. If you want the broader history of why decentralized finance exists at all, our explainer on the background and operating features of DeFi covers that ground.

The short version

• A DeFi protocol is on-chain logic in smart contracts that holds funds, enforces rules, and settles transactions without a bank, while a dApp is the interface layer that sits on top of one or more protocols.
• Seven categories cover most value locked on-chain today: lending, decentralized exchanges (DEXs), derivatives, yield, stablecoins, liquid staking, and bridges. Real-world asset protocols have since grown into an eighth.
• DeFi protocols run as a five-layer stack, from the base chain up to the aggregators, so a bug in a lower layer cascades into everything built above it.
• Lending protocols run on overcollateralization, DEXs replace the order book with an automated market maker (AMM), and the highest-risk categories are algorithmic stablecoins, leveraged derivatives, and cross-chain bridges.
• DeFiLlama measured $74.9 billion locked across DeFi protocols on 5 August 2026, down from a January peak of $127.7 billion. Lido and Aave were the two largest single protocols.
• Judge a specific protocol by its total value locked (TVL), audit history, time in production, and how cleanly it composes, not by its advertised yield.

What is a DeFi protocol

A DeFi protocol is a set of smart contracts that performs one financial job on a public blockchain, with the contracts themselves holding the funds and enforcing the rules. There is no account to open and no company that can freeze your position. You send a transaction and the contract settles it.

The single-job part of that definition does most of the work. Aave handles lending, Uniswap handles swaps, Lido handles staking, and each is a protocol in roughly the sense that HTTP is a protocol: a published set of rules that other software can call, without an owner or a support line behind it. Decentralized finance protocols get their reach from being callable by anything, including each other.

Three things follow from the definition, and each one has practical consequences:

• The contracts custody the money. A lending protocol does not arrange a loan for you the way a bank does. It is the vault, and whatever the contract permits is what can happen to your funds.
• The rules are public and fixed at deploy time. You can read exactly how interest accrues before you deposit. You can also read the upgrade path, which is where the real governance risk hides.
• Anyone can build on top without permission. No integration agreement, no API key. This is what makes DeFi compose, and it is why one protocol's failure becomes several protocols' problem.

DeFi protocol vs dApp vs platform

A protocol is the rule set encoded in smart contracts; a dApp is the product people click; "platform" is marketing language that means whichever of the two the speaker finds convenient. That sloppiness causes real confusion when you're scoping a build, because the three things carry different risk and different work.

The protocol defines how collateral is locked, how interest accrues, and how a swap is priced. A dApp is the interface and orchestration layer sitting on top, and it is usually what people mean when they talk about a decentralized application. Several front ends can talk to the same protocol, and one product can compose many protocols into a single user flow. Uniswap the contract set and Uniswap the website are separate things, and the website going dark would not stop the contracts.

That composability is the point. Each protocol exposes functions any other contract can call, so a yield app can route deposits into a lending market, which itself prices a token using an oracle, which a stablecoin relies on for its peg. This is why people call DeFi "money legos." It's also why a bug in one base layer can cascade through everything built above it.

Composability is DeFi's superpower and its biggest attack surface. Every integration you add is a dependency you now have to trust.

How DeFi protocols work: the five layers of the DeFi stack

DeFi protocols work by stacking five layers, each depending on the one beneath it. The model is an industry teaching framework rather than a formal standard, but it is the clearest way to see where a given protocol sits and what it inherits from below.

• Settlement layer: the base blockchain, such as Ethereum, Solana, or Bitcoin, where transactions finalize and balances are stored. This layer provides consensus and security for everything above it.
• Asset layer: the tokens that live on the settlement layer, including native coins like ETH, wrapped assets, governance tokens, and stablecoins. These are the instruments protocols lend, pool, and price.
• Protocol layer: the financial smart contracts themselves, the lending markets, AMMs, derivatives engines, and staking contracts. This is the layer this guide is about, and it is where the categories below live.
• Application layer: the user-facing dApps and wallets that turn raw contract calls into a usable interface. One app often orchestrates several protocols at once.
• Aggregation layer: the routers, dashboards, and yield optimizers that combine many protocols into a single action, plus analytics platforms like DeFiLlama that read across the whole stack.

A single transaction usually touches several layers at once. When you supply collateral to a lending market and borrow a stablecoin against it, the settlement layer records the transfer, the asset layer supplies the tokens, the protocol layer runs the collateral and interest math, and an oracle feeds in the price that decides whether your position is healthy. That oracle dependency matters more than most people expect: a protocol is only as reliable as the price feed it trusts, which is why the smart contracts that power DeFi are audited as much for their data inputs as for their own logic.

The main types of DeFi protocols

There's no official registry of protocol types, but seven categories cover the overwhelming majority of value locked on-chain today, with tokenized real-world assets having grown into an eighth over the past two years. Most real products combine two or three of them.

Three more categories belong on the map even though they barely register in the value rankings, and the reason they don't register is the interesting part: none of them custody your money.

Reading a category ranking by TVL alone therefore hides the pieces most likely to break your integration. An oracle holds nothing and can still take down a lending market, which is why our explainer on how DeFi works at the contract level spends as long on price feeds as on pools.

Lending protocols

Lending protocols are the closest thing DeFi has to a savings-and-loan business, minus the loan officer. Suppliers deposit assets into a shared pool and earn interest. Borrowers post collateral and draw against it. Rates float algorithmically based on how much of the pool is borrowed at any moment.

That shape is not a sketch, it is four numbers held in a contract. Aave sets a base rate, a first slope, an optimal utilization point, and a second slope, then draws a straight line to the optimal point and a much steeper one after it. The USDC reserve on Aave v3 Ethereum Core was running a base of 0 percent, a first slope of 4 percent, an optimal point at 92 percent, and a second slope of 10 percent when we read the strategy contract on 5 August 2026. Borrowing costs 4 percent when the pool is 92 percent lent out and 14 percent when it is fully lent out, and the whole of that jump is squeezed into the last 8 percent of the pool.

The steep second slope is not a pricing quirk, it is the withdrawal guarantee. Suppliers can only pull their deposits out if some of the pool is still sitting there unborrowed, so the protocol makes the last slice punitively expensive to borrow and lets the rate push borrowers into repaying. Every lending protocol has some version of this curve, and the parameters are governance decisions you can look up rather than fixed properties of the technology.

The defining feature is overcollateralization. To borrow $1,000 of USDC you might lock $1,500 of ETH. If your collateral value drops past a threshold, liquidators repay your debt and seize the collateral at a discount, which keeps the pool solvent without anyone needing to chase you for payment.

Aave and Compound wrote the reference implementations, though the shape of the category has changed since. Compound now holds around a tenth of Aave's deposits, while Morpho, which strips lending down to isolated permissionless markets with curated vaults layered on top, has become the second-largest lending protocol by TVL. Sky, the protocol that was MakerDAO until its August 2024 rebrand, occupies a related niche by minting the USDS and DAI stablecoins against deposited collateral.

When you evaluate a lending market, look hard at:

• Oracle design: bad price feeds cause unfair liquidations or let attackers drain pools.
• Liquidation parameters: thin liquidation incentives leave bad debt on the books during volatile moments.
• Pool isolation: whether a single toxic asset can poison the whole market or is ring-fenced. This is the design axis where Aave's shared pools and Morpho's isolated markets genuinely differ, and it decides how much of the protocol one bad listing can take down.

DEX protocols and the AMM model

DEX protocols let people trade tokens without an order book or a custodian holding their funds. The dominant design is the automated market maker (AMM), which replaces matched buyers and sellers with a liquidity pool and a pricing formula.

Uniswap popularized the constant-product model, where the product of the two token reserves stays fixed and the price moves along a curve as people trade. Liquidity providers deposit pairs and earn a cut of every swap. Curve specialized the curve math for stablecoin pairs that should trade near 1:1, cutting slippage dramatically. Balancer generalized pools to many assets with custom weights. Uniswap v4, live on mainnet since 31 January 2025, went a step further by letting developers attach "hooks" that run custom logic at points in a swap, which turns the AMM from a fixed formula into something closer to a platform.

Two trade-offs dominate any DEX integration:

• Slippage and depth: thin pools punish large orders with bad pricing. Aggregators route across many pools to soften this.
• Impermanent loss: when pool prices diverge from the outside market, liquidity providers can end up worse off than if they'd simply held. It's the single most misunderstood number in DeFi.

One warning about reading DEX rankings. TVL badly understates this category, because a DEX is a flow business rather than a storage business. Uniswap held about $3.0 billion in pools on 5 August 2026 while its v3 and v4 deployments routed roughly $50.8 billion of swap volume over the preceding 30 days, according to DeFiLlama. Judge a DEX on volume and fee capture; judge a lending market or a staking protocol on deposits.

If you're weighing a custom DEX against integrating an existing one, that's a build-versus-buy call our blockchain development team runs with clients regularly, and the honest answer is usually to compose rather than reinvent the AMM.

Derivatives protocols

Derivatives protocols bring perpetual futures, options, and synthetic assets on-chain. Perpetuals are the heavyweight here by volume: leveraged positions with no expiry, kept honest by a funding rate that nudges the contract price toward the spot price.

These are the most mechanically demanding protocols to get right. They have to source reliable mark prices, manage a margin and liquidation engine, and absorb extreme volatility without going insolvent. They are also the category where the leaderboard has turned over hardest. dYdX and GMX took different architectural bets, one closer to an order book, the other pooling liquidity against traders, and both defined the category between 2021 and 2023. By August 2026 DeFiLlama put dYdX at about $115 million and GMX at about $177 million, while Hyperliquid, which runs a fully on-chain order book on its own layer-1, held about $6.3 billion in its bridge contract alone.

The risk here is leverage amplifying everything. A pricing or oracle flaw that's a nuisance in a lending market can wipe out a derivatives protocol in a single block.

Synthetic asset protocols

A synthetic asset protocol issues an on-chain token that tracks the price of something the protocol does not actually hold. Collateral and an oracle price feed stand in for custody of the underlying, so a contract can mint a token that follows gold, an equity index, or a foreign currency without anyone warehousing bullion or shares.

Three distinctions are worth keeping straight, because search results blur them constantly:

• Synthetic asset vs wrapped asset. WBTC is wrapped rather than synthetic: real bitcoin sits with a custodian and each token is redeemable one-for-one. A synth gives you no such claim on anything, only collateral and a price feed.
• Synthetic asset vs perpetual. A perp is a position inside one venue. A synth is a transferable token, so it can be lent, pooled, or used as collateral elsewhere, which is the whole appeal and also the way its risk propagates.
• Who is the counterparty. In the pooled-debt model that Synthetix popularized, everyone who mints a synth shares one collective debt pool, so your liability moves when other people's synths move. That mechanic is elegant and it is also the thing new integrators most often fail to price.

The category has contracted sharply. Synthetix, which minted the original synths, has consolidated onto Ethereum mainnet, deprecating what it calls "all L2 AMMs in favor of a single Ethereum Mainnet CLOB Perp DEX," and its governance moved to retire the sUSD stablecoin after a prolonged depeg. Pooled-debt synths turned out to be much harder to keep stable than an order book with real margin behind it, and the capital went where the stability was. If you need on-chain exposure to an off-chain asset today, tokenized real-world assets with a legal redemption right are generally the sturdier route.

Yield protocols

Yield protocols sit on top of everything else. Rather than holding a position manually, you deposit into a vault that automatically allocates across lending markets, liquidity pools, and reward programs, harvesting and recompounding returns.

Yearn made vaults a household name in DeFi by abstracting strategy execution away from the user, and Pendle later added a different angle by splitting a yield-bearing token into a principal leg and a yield leg that trade separately. The appeal is obvious: better returns without babysitting positions. The catch is equally clear. A yield vault inherits the risk of every protocol it touches, plus the risk of its own strategy code. Yield is a stack of dependencies, and the advertised APY rarely prices in the tail risk underneath it.

If you're chasing returns, read our breakdown of how to take advantage of DeFi and the risks of yield farming before you commit capital. The mechanics that generate yield are the same mechanics that can vaporize it.

Stablecoin protocols

Stablecoins are the settlement currency of DeFi, and the protocols that issue them come in distinct flavors with very different risk profiles.

• Collateralized by fiat: USDC and USDT hold off-chain reserves. Simple peg, but you trust the issuer and their banking. This model accounted for $282.7 billion of the $308.8 billion in stablecoin supply DeFiLlama tracked on 5 August 2026.
• Crypto-collateralized: USDS and DAI are minted against on-chain collateral via Sky, overcollateralized to absorb volatility. Transparent, but exposed to collateral crashes. This group held $25.8 billion, about 8 percent of supply.
• Algorithmic: pegs maintained by supply-and-demand mechanics rather than reserves. This category has by far the worst track record, and its remaining supply is $0.3 billion, one tenth of one percent of the total.

One tenth of one percent is a useful number to carry around. Nobody argued algorithmic stablecoins out of existence, and the debate about whether the mechanism can work in principle is still going. Holders simply left. If a design deck lands on your desk proposing one, the burden of proof sits entirely on the person holding the deck.

When a stablecoin is the unit of account across your product, its peg mechanism is your foundation. A depeg doesn't stay contained, it propagates into every lending market and pool that quotes against it.

Liquid staking protocols

Liquid staking is one of the newest major categories, and it solved a real problem. Staking proof-of-stake assets like ETH locks them up. Liquid staking protocols let you stake and receive a tradable receipt token representing the staked position plus rewards.

Lido and Rocket Pool are the leading examples, and Lido's $17.6 billion in TVL made it the largest single protocol in all of DeFi on 5 August 2026. That receipt token can then be used as collateral, swapped, or dropped into a yield vault, so your capital earns staking rewards and stays productive elsewhere. It's composability applied to staking. Restaking extends the same idea one step further by pledging staked ETH to secure additional services, which is the business EigenCloud, formerly EigenLayer, rebuilt itself around in 2025.

The trade-offs are specific: validator performance and slashing risk, the depeg risk of the receipt token versus the underlying asset, and the centralization concern when one protocol controls a large share of total stake on a network.

Bridge and cross-chain protocols

Bridge protocols move assets and messages between separate blockchains, which are otherwise unable to talk to each other. The common design locks a token on the source chain and mints a wrapped version on the destination chain, then burns and releases when you move back. Newer messaging protocols generalize this to arbitrary data, not just tokens.

Bridges are what make a multi-chain DeFi world usable, and they are also the most dangerous category to trust. A bridge holds locked value on both sides and depends on off-chain validators or relayers to confirm what happened, which creates a large and concentrated target. As the risk section below shows, cross-chain bridges have lost more money to exploits than any other type of DeFi protocol. If you must bridge, prefer protocols with conservative validation, a long incident-free history, and value caps that limit the blast radius of a single failure.

How much value is locked in DeFi protocols

Total value locked (TVL) is the dollar value of assets deposited in a protocol's smart contracts, and it is the headline gauge of how much a DeFi protocol is actually trusted. TVL is not the same as revenue or market cap. It counts the capital that users have chosen to park inside the contracts.

Across all chains, DeFiLlama measured $74.9 billion locked in DeFi protocols on 5 August 2026. That figure had moved between $69.0 billion in early July and $127.7 billion on 18 January over the course of the year, and the swings tracked the broader crypto market more than they tracked any change in how the protocols work.

Three caveats make TVL far less precise than it looks, and knowing them is most of what separates a useful reading from a misleading one:

• It is priced in dollars. A protocol whose deposits never move still shows TVL falling in a downturn, because the tokens inside it are worth less. A good part of the drop above is repricing rather than people withdrawing.
• Category totals double count. Stake ETH with Lido, take the receipt token, deposit it into Aave, and the same ETH is counted twice. DeFiLlama de-duplicates for its headline figure, which is why the categories in the chart above sum to far more than $74.9 billion.
• It is the wrong metric for flow businesses. DEXs and perpetuals venues turn capital over many times a day. Their TVL says almost nothing about how much trade they carry.

Stablecoins operate at a different scale again, and on a different metric: $308.8 billion in circulating supply, led by USDT at $183.1 billion and USDC at $72.3 billion. Those stablecoins are the settlement currency that flows through every other category.

A list of the biggest DeFi protocols by category

Below is a list of the largest DeFi protocols in each category, measured on DeFiLlama on 5 August 2026. How it was built, so you can reproduce or challenge it:

• One source, one date. Every figure comes from DeFiLlama on 5 August 2026. Nothing is carried over from an older draft, and nothing is averaged across dates.
• Parent protocols, not deployments. Versions and chains are summed under the parent, so "Aave" means Aave v2 and v3 across all 23 chains rather than a single market.
• Centralized exchanges excluded. DeFiLlama tracks exchange wallet balances alongside protocols. Those are custodial businesses, not DeFi protocols, and they are filtered out here.
• Leaders per category, not a global top 30. Ranking everything by TVL alone would fill the table with staking and bridges and show you no DEXs at all.

The ordering inside a category can change within weeks, which is the point of the date stamp: you can go re-measure it at defillama.com rather than trusting a number of unknown vintage. The category labels are DeFiLlama's own, and they occasionally sit oddly with how a protocol describes itself.

SSV Network is the clearest illustration of the double-counting caveat above. The ETH it secures is also counted inside the staking protocols whose validators run on it, so its $9.3 billion overlaps with Lido's $17.6 billion rather than adding to it.

Stablecoin protocols belong on a separate scale, because circulating supply rather than TVL is the meaningful measure. On the same date DeFiLlama tracked:

Almost everything near the top of both tables has been running for years and has been audited repeatedly. The newest name up there is Morpho, and it won its position by making lending markets smaller and more isolated instead of by adding features. Capital in DeFi is conservative in a way the marketing never is.

The main risks of DeFi protocols

Every DeFi protocol concentrates value in code, and the risks all trace back to that fact. A protocol can be economically sound and still lose everything to a single flawed line, so risk assessment is less about yield and more about how a protocol can break.

• Smart-contract risk: a bug in the contract can be drained in one transaction, and immutable code means a mistake ships permanently until a migration. Audits reduce this risk but never remove it.
• Oracle manipulation: distorting the external price feed a contract trusts so it executes at the wrong value, often funded by a flash loan, which turns a data problem into a theft.
• Impermanent loss: the value an AMM liquidity provider gives up versus simply holding, when the pooled tokens' prices diverge and the curve rebalances the amounts against them.
• Liquidation cascades: in leveraged lending and derivatives, a sharp price move can trigger mass liquidations that push the price further, feeding the next round.
• Rug pulls and governance capture: insiders who keep admin keys or a governance majority can drain funds or change the rules, so an "immutable" contract with a live upgrade key is not immutable at all.
• Off-chain infrastructure: the servers, relayers, and verifier sets a protocol depends on sit outside the audit scope and outside the chain, and they have proven easier to attack than the contracts.
• Bridge exploits: the single largest category of DeFi theft by dollars lost, because bridges combine the two risks above with a large pool of locked value.

The bridge numbers make the point on their own. DeFiLlama's hacks database listed 612 incidents totalling $16.9 billion as of 5 August 2026. Filter it to incidents where the target was a DeFi protocol and the total is $7.9 billion; filter it to bridges and 61 incidents account for $3.3 billion, which is roughly 42 percent of all DeFi protocol losses from about 10 percent of the incidents.

What the Kelp DAO exploit changed

On 18 April 2026 an attacker took roughly $292 million in rsETH out of Kelp DAO's LayerZero bridge, and the way it happened breaks the pattern most integration checklists are built around. According to Chainalysis, "This was not a smart contract vulnerability. There was no reentrancy bug, no missing access check, no price oracle sleight-of-hand."

What failed was configuration and infrastructure. The bridge ran a 1-of-1 verifier setup, meaning a single decentralized verifier network confirmed cross-chain messages with no independent second opinion, and that verifier read prices and state from RPC nodes the attacker was able to compromise and overload at the same time. Funds were released on the destination chain without matching burns on the source chain. LayerZero attributed the operation to the DPRK-linked Lazarus Group.

Two lessons carry over to any protocol you integrate. A configuration choice made for latency and gas cost can quietly become the single point of failure that an audit report will never mention, because it is not in the contracts. And "audited" is a statement about code, not about the operational surface around it. When you do your diligence, ask who verifies cross-chain messages, how many of them there are, and what happens when one of them lies.

None of this means DeFi is uninvestable, and it is worth keeping separate from the question of whether DeFi is legal, which varies by jurisdiction and is still being written. It means the diligence has to be real. Weighing these dependencies is an exercise in blockchain security, and it is the part that separates a protocol that looks good in a demo from one that survives adversarial conditions.

How to choose between DeFi protocols

There's no universally best DeFi protocol. There's the one that fits your product, your risk tolerance, and your users. A few questions cut through most decisions.

What problem are you solving? Custody-free trading points to a DEX. Idle-capital returns point to lending or yield. Leverage and hedging point to derivatives. Cross-chain movement points to a bridge. Match the category to the job before you compare names within it.

How battle-tested is the code? Total value locked, audit history, time in production, and how the protocol handled past incidents tell you more than any whitepaper. A protocol that survived a market crash with no bad debt has proven something a six-month-old fork hasn't, and a smart contract audit is a floor rather than a verdict.

What does it depend on? Trace the oracle, the collateral, the governance, and the upgrade keys, then keep going past the contracts into the relayers, verifier sets, and RPC providers. Every dependency is something that can fail or be captured. Admin keys that can drain the contract are a different risk class than an immutable deployment.

Does it compose cleanly? If you're building on top, the protocol's interfaces, documentation, and the ecosystem of tooling around it decide how painful integration will be.

Pick protocols the way you'd pick load-bearing dependencies in any system: by track record, blast radius, and how cleanly they fail.

For teams moving from these fundamentals toward an actual build, we go deeper on architecture and delivery in our look at DeFi development and the future of decentralized finance, and if you want the market picture, our read on the DeFi trends shaping the future of finance sets the direction of travel. The categories above are stable, but the implementations evolve fast, and the gap between a protocol that looks good in a demo and one that holds up under real conditions is where most projects either succeed or get exploited.

The taxonomy gives you the map. Knowing which DeFi protocols to trust with real money is the work, and it doesn't get easier with hype, only with reading the code, the audits, and the incident history. Re-measure the list above before you act on it, because half the point of a DeFi protocol ranking is how quickly it goes stale.