Mark Price vs. Index Price vs. Last Price

 

Understanding the lingo of crypto perpetual futures can feel like learning a new language. Ever opened a futures trading screen and seen three different prices for the same coin? Don’t worry – you’re not seeing triple! These are the Mark Price, Index Price, and Last Price. In this article, we’ll break down each one and explain why they matter (especially for liquidations), and compare how Binance (a CEX) uses them versus DEX platforms like dYdX, Hyperliquid, and GMX. By the end, you’ll know who “Mark” is, why everyone talks about an “Index,” and what the “Last” trade price really means for your positions.

Introduction: Three Prices, One Coin?

Imagine you’re trading Bitcoin perpetual futures. You glance at the screen and see something like: Last Price: $90,600, Mark Price: $90,610, Index Price: $90,614. Huh? Why are there three prices, and why are they all slightly different? If you’re new, it’s easy to feel like the exchange is playing tricks on you. But each of these prices has a specific purpose designed to keep the market fair and prevent nasty surprises like sudden liquidations.

In a nutshell:

• Last Price is the price of the most recent trade – basically what someone just paid for the contract.
• Index Price is like an average market price of Bitcoin from multiple sources – a reference for the “true” price.
• Mark Price is a calculated fair value of the futures contract, often derived from the Index Price (with some magic math) to avoid manipulation. It’s the number used for margin calculations and liquidation triggers.

They might sound abstract now, but we’ll demystify each one with examples and comparisons. Think of Last Price as the “hype man” reflecting the latest trade, Index Price as the “trusted external advisor” giving the real-world price, and Mark Price as the “referee” ensuring the game stays fair. Let’s dive into the details.

What is the Last Price?

Last Price is the simplest of the trio: it’s literally the price at which the last trade was executed on that platform. If someone just bought 1 BTC perpetual contract at $34,600, the Last Price is $34,600 until another trade happens. It updates in real-time with each trade.

• Represents: Real-time market trading on that exchange – basically where buyers and sellers most recently agreed to trade.
• Volatility: It can swing wildly in illiquid markets or during sudden buys/sells. The Last Price might spike or drop due to a big market order or a “flash crash” moment.
• Use: It’s used for charting and for realized PnL – when you close a position, your profit/loss is based on the price you actually traded (which is a Last Price). It’s also often the default trigger for things like stop-loss or take-profit orders unless you choose otherwise.

In short, the Last Price is the actual trading price on the exchange at that moment. It’s like the spotlight price everyone sees on the chart and in the trade history. However, because it can be influenced by a single large trade, it’s not always a reliable indicator of the asset’s fair value in a volatile moment. One crazy trade could temporarily push Last Price way off the true market value.

A quick example: If someone fat-fingers an order and accidentally buys a perpetual contract 5% above market, the Last Price will jump 5% up momentarily (that would be a spike to around $95,000) – even if Bitcoin’s price elsewhere hasn’t moved. If we used Last Price for everything, a bunch of people might get unfairly liquidated or see bizarre PnL swings due to that one-off trade. That’s where our other friends, Mark and Index, come in to save the day.

What is the Index Price?

Index Price is essentially an external reference price for the underlying asset. It’s often calculated as a weighted average of the asset’s prices across multiple major exchanges. Think of it as the “true value” of Bitcoin according to the broader market, not just one exchange’s data.

• Represents: The real-time global spot price of the asset. For BTC perps, the index might pull data from, say, Coinbase, Kraken, Bitstamp, Binance spot, etc., to get an aggregated price.
• Calculation: Typically a volume-weighted average price (VWAP) from multiple exchanges. Higher-volume markets influence it more. Exchanges also apply safeguards – e.g., ignoring an exchange price if it deviates too much from others (to prevent one rogue source from skewing the index). This makes the Index Price stable and manipulation-resistant.
• Use: It’s used as a fair benchmark. Exchanges use the index to derive the Mark Price and often to calculate funding rates (the periodic payments between longs and shorts). It’s also used for triggering stop orders on some platforms – for example, dYdX uses an off-chain Index Price to trigger stops so that a flash move on one exchange doesn’t trigger stops unnecessarily. The index itself usually isn’t directly tradable; it’s just a reference.

The Index Price is like a consensus of “what’s Bitcoin worth right now across the market.” It tends to be stable and reflects broad market reality, smoothing out any one exchange’s odd moves. This is super important because a derivative should ultimately track the real asset’s price; the index is that tether to reality.

Example of an Index Price calculation (OKX exchange). In this sample from OKX, the index is composed of five major exchanges (Kraken, Bitstamp, Bitfinex, Crypto, Coinbase), each given a 20% weight. This produces a fair composite price (shown in red/green for each source) for BTC/USD. Such an aggregated price feed is used as a stable reference for the futures contract’s value. By taking multiple sources, no single exchange’s outlier price can significantly skew the index.

Why the Index Price matters: Suppose Exchange X has a glitch and BTC’s Last Price suddenly crashes to $80k while other exchanges are at $90k. The index will barely budge (since it averages many sources, and most are still ~$90k). So the index protects traders from Exchange X’s glitch. It’s considered the ground truth for the asset’s price. Many platforms say the index price “is used as a fair reference price for liquidations” – meaning if the underlying real market isn’t actually crashing, they won’t liquidate you just because one platform’s Last Price did something crazy.

What is the Mark Price?

Now for the star of the show: Mark Price. The Mark Price is a computed fair price of the perpetual contract, and it’s the price that matters most for your PnL and liquidation. In a sense, it’s the exchange’s best guess of what the contract is truly worth, taking into account the broader market.

• Represents: An estimated fair value of the futures contract. It’s designed to closely track the Index Price (the underlying), but also factor in futures-specific influences like funding rates or basis. It’s not an actual trade price; it’s a theoretical price used internally.
• Calculation: Varies by exchange, but usually derived from the Index Price plus/minus some adjustments. For perpetuals, one common adjustment is a funding basis rate – essentially accounting for the accumulated funding payment up to the next funding timestamp. For example, BitMEX’s formula: Mark Price = Index Price * (1 + Funding Rate * (time until funding / funding interval)). This means if the futures price is above spot (positive funding), the Mark Price will be slightly above the Index (and vice versa), to reflect that futures are pricier until funding brings them back. Exchanges also often smooth the Mark Price by averaging or imposing caps so it doesn’t jump around too much. On some platforms, Mark Price is basically the median of various prices – e.g., Hyperliquid takes the median of (its own orderbook mid-price vs oracle vs other exchanges) to compute a robust Mark.
• Use: Unrealized PnL and margin calculations are based on Mark Price, not Last Price. More critically, liquidations are triggered by Mark Price hitting your liquidation price, not by Last Price. Mark Price is the guardrail to prevent unfair liquidations. It’s also used for triggering auto-deleveraging or margin calls, and for calculating funding payments themselves on many exchanges (since funding is often based on how far the contract is trading away from the index/mark).

In simpler terms, Mark Price is the exchange saying: “Given everything we know (spot prices elsewhere, our own order book, and time till funding), this is what the contract should be worth right now.” It tends to stay very close to the Index Price – if the futures market is in sync with the spot market, Mark and Index will be nearly equal. If the futures price starts wandering off (due to high demand or low liquidity), Mark Price will usually still stick near the Index and not fully follow the Last Price into crazy territory. This gives traders a buffer.

Key point: Your position will only liquidate if Mark Price hits your liq price, not the Last traded price. That’s huge. It means if someone attempts a “scam wick” (pushing the Last Price sharply to stop-hunt), as long as the broader market doesn’t agree with that move, the Mark Price won’t fully chase it, and you might be safe from liquidation.

A futures trading interface showing all three prices (Index, Mark, and Last). In this example, the Index price (top left, orange highlight) is the external market price of BTC, the Mark price (next to it) is slightly different – a fair value used for PnL and liquidation, and the Last price (shown in the chart and order book) is the most recent traded price on this exchange. Notice how the Mark Price and Index Price are very close, while the Last Price might momentarily diverge due to a quick trade. Exchanges display all three so traders know the context: e.g., if Last Price drops but Mark stays steady, it’s likely a brief aberration rather than a true market crash.

Mark Price vs. Index Price vs. Last Price – Quick Comparison

To summarize the differences, here’s a comparison of the three price types in a handy table:

Aspect	Index Price (Reference)	Mark Price (Fair Value)	Last Price (Trade Price)
Definition	Weighted average price of the underlying asset from multiple markets. A “spot market” reference price.	Calculated estimate of the contract’s true value, derived from Index plus adjustments (funding, etc.). Not directly traded.	The most recent traded price of the contract on this exchange. The actual execution price of last trade.
Data Source	External exchanges (spot prices on major venues, weighted by volume). Often uses multiple exchanges for robustness.	Internal formula using Index Price, sometimes the exchange’s own order book data, and funding rate. Updated frequently (every few seconds or each tick).	The exchange’s own order book/trades. Determined by the latest match between a buyer and seller on the platform.
Stability	High: Stable and resistant to any single market’s manipulation. Ignores outliers (e.g., one exchange outage or rogue price).	High: Smoothed/filtered to reduce short-term volatility. Tracks underlying closely, doesn’t jump on momentary spikes.	Low: Most volatile. Can swing with big orders or thin liquidity. Might show flash crashes or spikes that differ from global price.
Primary Purpose	Provide a fair benchmark for the asset’s price. Used as the foundation for Mark Price and for cross-exchange fairness.	Risk management: used for margin calculations, unrealized PnL, and liquidation triggers. Prevents unfair liquidations by being more steady. Also used to compute funding payments in perps.	Price discovery and execution: shows what price trades are happening. Used for realized PnL (entry/exit prices) and often for triggering limit/stop orders if chosen. It’s the price you see on charts and tickers.
Liquidation Role	Indirect: The index is often the input to Mark Price (which actually triggers liquidation). In some cases, if the perp diverges a lot, the index ensures Mark Price doesn’t stray beyond a % of it.	Direct: Critical for liquidation. A position liquidates when Mark Price hits the liquidation threshold. By basing on index, it “ensures traders are not unnecessarily liquidated” by short-term swings.	None for liquidation triggers (not used because it can be manipulated short-term). A crazy Last Price alone won’t liquidate you unless it drags Mark Price with it.
PNL Calculation	Not used directly in PnL, but since Mark is near Index, it anchors unrealized PnL fair value.	Unrealized PnL is calculated using Mark Price (difference between Mark and your entry). This prevents PnL from seesawing with every tiny trade.	Realized PnL uses your actual trade prices (which are Last Prices). Also your entry and exit are at Last Prices. So it determines the final profit or loss when closing a trade.
Analogy	“Market consensus price” – like an average of many thermometer readings to get the true temperature.	“Fair temperature” reading in our isolated system – adjusting the outside temp for local factors (like how AC or heating might skew local reading), ensuring we react only to real changes.	“Thermometer on site” – the reading at this exact location, which might spike if someone opens a window (temporary draft) even if outside temp hasn’t changed.

As you can see, each price serves a different role. Index is the grounding in reality, Mark is the protective mechanism for fairness, and Last is the immediate market action on the exchange.

Why All Three? (The Liquidation Mechanism & Fairness)

The reason we have these three prices is largely about risk management and fairness. Liquidation (when the exchange forcefully closes your leveraged position because you ran out of margin) is something everyone fears – and these mechanisms exist to make sure liquidations happen fairly, not due to some momentary blip.

Using Last Price alone for liquidation would be chaos. If the exchange liquidated positions based on the Last traded price, a single big trade could trigger a cascade of liquidations. Imagine a whale sells a ton of contracts, the Last Price plummets 10% in seconds on this platform, tons of traders get liquidated because the Last Price hit their stop-out. Then the price bounces right back after the whale’s done. That would be unfair and unnecessary. We’ve seen in traditional markets and poorly designed systems how a flash crash can wipe people out. Crypto exchanges learned from those lessons.

By using Mark Price (which is anchored to the broader market via the index), the exchange ensures you’re only liquidated if the real market moved against you, not just some local freak trade. As an academic paper put it: “This mechanism protects traders from flash crashes in perpetual contracts, and traders are therefore only liquidated if the spot market moves in an adverse direction.” In other words, if the whole market crashes, okay your long might liquidate. But if just one exchange has a momentary crash and the rest of the market is fine, Mark Price won’t fully follow that, and your position likely stays safe (provided the index didn’t move enough to warrant liquidation).

Liquidation example: Suppose your BTC long will liquidate at $85,000. BTC is at $90k globally. A sudden sell hits your exchange and the Last Price dumps to $84,500 for a few seconds. If we foolishly used Last Price, you’d be liquidated instantly at ~$85k. But the Index Price, drawn from many exchanges, might only dip to $88k (since other exchanges didn’t go crazy). The Mark Price might follow to maybe $87.5k – far above your $85k threshold – so you do not get liquidated. In a few seconds, that whale is done selling, Last Price jumps back to $90k, and life goes on. You survive a scare, all thanks to Mark Price reducing the impact of short-term volatility.

Mark Price also thwarts manipulation attempts. If a malicious actor wanted to liquidate a big account, they could try to execute a huge sell to tank the price on that exchange. But since the liquidation trigger is Mark (which won’t tank as easily), it’s much harder to force someone’s Mark Price to their liq level unless you move the entire global market or sustain a price difference until the index catches down. This protection is so important that nearly all major exchanges implement it. As one support doc bluntly states: “Mark Price is used to prevent unfair and unnecessary liquidations.”

Liquidation process (simplified): When Mark Price hits your liquidation price, the exchange will start the liquidation process – your position gets taken over by the liquidation engine. They might partially or fully close it at market (using order book or whatever mechanism) to cover the debt, and use insurance fund or auto-deleveraging if needed. But notably, that process ignores the Last Price – it’s all about Mark. Realized losses are determined when they actually execute the close (so that part involves trades and Last Prices), but the trigger is Mark Price reaching the threshold.

For traders, this means: always keep an eye on the Mark Price and your liquidation price. Don’t assume you’re safe just because the Last Price on the chart is above your liq – if Mark is lower (which it can be in a big move or if your exchange’s futures price is running higher than spot), you could be closer to liquidation than you think. On some UIs, you might see a “Margin ratio” or “Liquidation risk” indicator that is effectively based on Mark Price movement.

On the flip side, when placing stop-loss orders, you often have a choice: trigger on Last Price or Mark Price. This is interesting: If you trigger on Mark Price, your stop will only execute when the fair price reaches your level (avoiding getting stopped on a quick wick). If you trigger on Last Price (the default on many exchanges for immediacy), you might get a tighter execution but risk the scenario where Mark hits liquidation before Last hits your stop (meaning you could get liquidated before your stop triggers – not good!). Traders need to balance this, especially in thin markets. Many prefer Mark Price triggers for stops on illiquid contracts to avoid random wicks, but on very liquid markets it might not matter much since Mark and Last rarely diverge by large amounts for long.

Binance (CEX) vs dYdX, Hyperliquid, GMX (DEX) – How They Handle Prices

Different platforms have slight variations in how they calculate and use these prices, but the core idea remains: Mark Price for fairness, Index as reference, Last for actual trades. Let’s compare a top centralized exchange (Binance Futures) with some decentralized perpetual trading platforms (dYdX, Hyperliquid, GMX) to see how each approaches Mark, Index, and Last Price.

Binance Futures – The Classic CEX Approach

Binance Futures uses the standard model we’ve described. On Binance:

• Index Price: Binance has its own price index for each perpetual contract. It pulls data from multiple spot exchanges (like Coinbase, Kraken, etc.) with volume-based weights. They also apply filters: e.g., ignoring outlier prices and using medians if one source deviates too much. This index is displayed on their UI and updated frequently (typically every second).
• Mark Price: Binance’s Mark Price is based on that Index Price plus a funding basis. They have published formulas: essentially, Mark = Index * (1 + Funding_rate * (time until funding / 8h)) for perps. The Mark Price update continuously rather than jumping at funding time – this avoids sudden shifts. Binance also caps how far Mark can drift from Index: if the futures market price diverges a lot, Mark Price won’t exceed a certain % away from Index (to prevent large deviations). The Mark Price on Binance is used for all cross/isolated margin calcs, PnL, and liquidation. So even if Binance’s own order book has crazy moves, liquidations reference the Mark.
• Last Price: This is just the Binance Futures market price – where the latest trade happened. It’s used for charting, and by default, Binance triggers stop-loss and take-profit orders on the Last Price (though they give an option to use Mark price triggers for those orders if you prefer). Realized PnL for your trades on Binance is based on the price you actually buy/sell at (Last Price).

Binance’s system is quite robust. Historical note: In the May 2021 crypto crash, Binance’s index (and thus Mark) was lagging a bit behind the rapid market drop (because of averaging), which actually gave some traders a tiny bit more time before liquidation – a double-edged sword (some escaped liquidation, others got liquidated “late” at slightly worse prices because mark didn’t drop as fast as spot). It highlights that Mark Price smooths things: you might avoid liquidation on a quick wick, but if the move continues, Mark will catch up and you’ll liquidate a tad later, potentially at a worse level than an instantaneous last price trigger would have. Overall, though, this mechanism has protected countless traders from being wiped out by momentary anomalies. Binance also employs partial liquidations for large positions – meaning they try to reduce your position incrementally once you hit risk limits, using Mark Price to guide those triggers.

dYdX – Decentralized Order Book with Oracles

dYdX is a popular decentralized perpetuals exchange (initially on layer-2). It operates an off-chain order book similar to a CEX, but uses oracles for pricing data. Here’s how dYdX handles it:

• Index Price: On dYdX, what they call Index Price is an off-chain aggregated price from multiple exchanges, used primarily to trigger stop orders. This is similar to the index on Binance – a multi-source price that’s robust to any one exchange’s issues. They keep it off-chain for speed and update it very quickly.
• Oracle Price (Mark equivalent): dYdX relies on oracle prices (on-chain) for settlement, collateral valuation, and liquidations. In practice, dYdX has a partnership with Chainlink and others to provide a price feed for each asset. This Oracle Price serves the role of Mark Price – it’s the price used to determine if your account is under-collateralized and needs liquidation. Notably, they update the oracle price on their Layer-2 multiple times per second, so it’s pretty close to real-time and usually almost identical to the Index Price. The oracle price is aggregated from multiple data sources as well, offering flash-crash protection just like an index.
• Last Price: Since dYdX has an order book, there is a last traded price on dYdX, but interestingly, dYdX’s UI and API often highlight the mid-market price (the midpoint between best bid and ask) as a reference for traders. This Mid Market Price is basically dYdX’s internal fair price at any moment based on the order book. Traders on dYdX execute at last prices determined by matches in the book, just like on Binance.

In essence, dYdX’s Mark Price = Oracle Price, which tracks an index of global prices. So like Binance, you won’t get liquidated because one trader on dYdX pushed the price – you’d need the oracle (global price) to move. There was an instance in 2021 where a sudden crash on one exchange (Kraken’s ETH price flash-crashed) didn’t liquidate dYdX users because the oracle price (a global median) remained higher. That demonstrated the resilience of using oracles/indices.

One small nuance: Because dYdX’s stop-loss triggers use the off-chain index (which is similar to mark), most stops and liquidation conditions are looking at effectively the same price (global market price). This means less confusion for traders – they don’t really have to choose mark vs last triggers in UI; the platform inherently uses the safe reference for critical functions.

Hyperliquid – A Hybrid Approach

Hyperliquid is a newer decentralized perp exchange that tries to provide a CEX-like experience on-chain. It uses a clever hybrid pricing mechanism to determine Mark Price:

• Oracle Price: Hyperliquid pulls a weighted median price from top CEXes (Binance, OKX, etc.) for the underlying – this is their “oracle price,” updated every ~3 seconds by network validators. They actually use this mainly for funding rate calculation.
• Mark Price: Instead of relying solely on that oracle or solely on their own order book, Hyperliquid computes Mark Price as the median of three inputs: (1) the oracle price adjusted by a short-term EMA of their own market’s premium, (2) the median of Hyperliquid’s own best bid, best ask, and last trade, and (3) the median price of the perpetual on three major exchanges (Binance, OKX, Bybit). By taking the median of these, the result is quite robust. Even if Hyperliquid’s order book is momentarily thin, the external prices and oracle anchor the Mark. If external markets go wild but Hyperliquid lags, its own prices and the oracle balance it out. The Mark Price is updated every time a new oracle price comes (every few seconds).
• Index Price: In Hyperliquid’s terminology, the “oracle price” from CEXes is effectively the index. They ensure it’s unbiased since it doesn’t depend on their platform at all.
• Last Price: As an order book DEX, Hyperliquid has a last traded price. But like others, all margining and liquidation is based on the Mark Price. Hyperliquid explicitly states Mark Price is used for margining, liquidation triggers, and PnL.

The cool thing here is Hyperliquid’s Mark Price design is quite belt-and-suspenders. It’s hard to manipulate: you’d have to manipulate both Hyperliquid’s own order book and the external markets (or oracle) to move the Mark significantly. This protects traders on Hyperliquid arguably even more than a simpler index/mark might.

For example, if Hyperliquid had a shallow order book and someone tried a big dump causing Last Price to tank on Hyperliquid, the Mark might not go as low because it’s held up by the external medians. Conversely, if something bizarre happened on Binance’s BTC perpetual, Hyperliquid’s Mark might ignore that if Hyperliquid’s own market and the oracle disagree.

GMX – Oracle-Based Perpetual AMM

GMX is a decentralized perpetuals platform that’s quite different from order book exchanges. It uses a liquidity pool (AMM) and direct oracle pricing for trades. Here’s how pricing works on GMX:

• Index Price: GMX essentially uses price oracles (mainly Chainlink or similar) to fetch the underlying asset price. This oracle price, which is an aggregate of exchanges, serves as the Index Price and Mark Price all in one. In fact, on GMX, the oracle price is the execution price for trades – you trade at (or very close to) the oracle price, with maybe a small adjustment for the pool’s liquidity or spread. So the concept of Last Price on GMX is not the same as on an order book; the last trade didn’t set a new price, it just happened at whatever the oracle said.
• Mark Price: Since GMX uses the oracle price for everything, the Mark Price = Oracle Price. GMX documentation notes that the price used to calculate liquidation is based on the oracle and “does not factor in any negative or positive price impact” (i.e., it ignores the size of your trade). This means even if your trade would move the pool’s ratio a bit, for checking liquidation they only look at the pure oracle price.
• Last Price: One could argue the “last price” on GMX is just the oracle price of the last update, because trades themselves don’t create a new market price (unlike an order book). So there’s effectively no independent last price to consider – it’s always pegged to the index.

Implications: On GMX, because mark and index are effectively the same, there’s no divergence between Last and Mark like on other platforms. This simplifies things – you don’t worry about wicks at all. If Binance had a crazy wick but Chainlink oracle smoothed it out (which it usually would by taking a median over a short time), GMX traders might not even notice anything; their prices update a bit slower and won’t reflect that crazy spike or dip unless it was sustained. This can be very noob-friendly: one price to watch.

However, pure oracle pricing has its own considerations. For example, if the oracle lags during a fast market move, GMX’s price might freeze or update slowly – traders could find it hard to execute quickly during volatility (the flip side of being protected from quick spikes). There was an incident where a trader manipulated the price on a DEX that Chainlink was using and then took advantage on GMX (due to zero price impact trading at the oracle price), which led GMX to introduce some cooldowns and spread adjustments for large trades. But still, liquidations on GMX are determined by the oracle-fed mark price. If the oracle price hits your liq level, you’ll be liquidated – GMX will then execute the liquidation by selling your collateral into the pool at whatever price impact occurs, but the trigger was the oracle price crossing that threshold.

Another difference: GMX doesn’t have a traditional funding rate like order book perps. Since trades happen at oracle price and the pool (GLP) acts as counterparty, they balance via token weights and an % fee on skew. So the mark price and index price on GMX remain equal by design – there’s no concept of a perpetual trading above or below index because if demand is imbalanced, funding isn’t used to adjust price, instead open interest limits and dynamic fees come into play. For traders, this means you won’t see a “premium/discount” on GMX price; it’s always at oracle. In contrast, on Binance/dYdX, the futures price can drift from index slightly until arbitrage or funding pulls it back.

Other Platforms (Bybit, OKX, etc.)

Most other futures exchanges, centralized or decentralized, follow one of the above patterns:

• Traditional CEX (Bybit, OKX, BitMEX): have multi-exchange price indices and use Mark Price for liquidation. The formulas may differ slightly (BitMEX uses a fair price band, OKX uses moving average premium, etc.), but conceptually similar.
• Newer on-chain perps (Kwenta on Synthetix, for example) use oracle pricing similar to GMX – with mark = index = oracle. In fact, both Kwenta and GMX are known to use oracle-fed prices, eliminating any difference between mark and index in practice.
• Hybrid designs (like Aark or Vertex) also have index oracles and mark prices, often trying to innovate on how to blend on-chain data with off-chain feeds for stability.

Real-World Example: The Liquidation Dance 💃

You’re dancing on the edge of a margin call, longing BTC with 50x leverage (you daredevil, you!). Your liquidation price is $86,000. Currently, Index says $90,000, Mark is at $90,050, and Last on your exchange is $90,100.

Suddenly, a wild Elon tweet appears and someone market sells a ton of BTC perps on your exchange. Last Price plunges to $86,500 in a blink. Your heart skips a beat – that’s awfully close to $86k! But you notice Mark Price only slid to $89,200 because the index (global price) is still around $89,500 (other exchanges didn’t drop as much). You’re safe… for now.

Moments later, arbitrage traders swoop in, buying the underpriced contracts on your exchange (since elsewhere BTC is higher) – this pushes Last Price back up to align with the index around $89,500. Mark Price never even got near $86k, so you weren’t liquidated. You live to trade another day, maybe with a stern warning to yourself about leverage.

Now, had that crash been real – say BTC dumped across all exchanges to $85k – the Index Price would have reflected it, Mark Price would have dropped accordingly, and once Mark hit $86k, your position would auto-close. That’s the liquidation dance: Mark Price leads, and if it hits the line, the music stops. Last Price is just a volatile dancer on one floor, and Index is the DJ mixing the tunes from all clubs.

(Okay, analogy over – back to serious mode.)

Graphing the Differences

It’s useful to visualize how these prices move during market events:

• Stable times: All three lines (Last, Mark, Index) hug each other closely. You’d barely notice a difference on a chart.
• Volatile spike on one exchange: Last Price on that exchange might zigzag sharply, while Index (and thus Mark) move more smoothly. Mark might be a smoothed version of Last, lagging slightly or ignoring the extreme points.
• Global move: All three move together in the same direction, but Mark/Index might still be a touch delayed or smoother than Last on that platform.

Consider a 1-minute candlestick chart where we plot Index Price and the exchange’s Last Price. Mark Price would follow Index very closely (maybe nearly overlapping). When a giant sell hits the exchange, you’d see the Last Price candle wicked down and up, whereas the Index/Mark line likely showed a much smaller dip. If a liquidation was triggered, it would correspond to the Mark line crossing a threshold.

(Graphical illustrations omitted here, but imagine a red line (Last) spiking down and back up, while a blue line (Mark) gently dips and returns, never reaching as low – that gap is all the traders saved from liquidation!)

Conclusion: Key Takeaways for New Traders

Trading perps can be tricky, but knowing these price types arms you with insight:

• Always watch the Mark Price for your positions – that’s the one that determines margin calls. Don’t panic if you see a wick on the chart; check where Mark is.
• Index Price is your friend – it tells you if a move is genuine or just local. If your platform’s price diverges a lot from the index, arbitrage or funding will likely bring it back in line soon.
• Last Price is mainly for execution – it’s where you’ll actually get filled. For setting stops, decide if you want to use Last or Mark: Last might trigger sooner (good for fast exits), Mark might be safer to avoid false triggers.
• On Binance and major CEXes, Mark and Index are clearly shown – use them. On DEXes like GMX, you effectively just have the oracle price, which simplifies things (but be mindful of oracle delays).
• Different platforms tweak the formula, but the philosophy is consistent: protect traders from short-term price insanity. As one exchange puts it, the Mark Price “provides a more stable and realistic valuation of an asset” to protect from unfair liquidation events.

In summary, Mark Price vs. Index Price vs. Last Price is not a battle but a teamwork. Index informs Mark, Mark moderates Last, and Last is free to do its dance without directly wrecking your account. When you place that next 100x degen trade (not that we recommend it!), you’ll know exactly who Mark, Index, and Last are – consider them the guardian angel, the anchor, and the troublemaker respectively. And now you can trade with a bit more confidence and maybe impress your friends by explaining why their position liquidated even though the wick didn’t hit their stop (“It was the mark price, my friend!”).

Happy trading, and may your Mark Price always be in your favor! 🚀

sources: Mark/Index/Last definitions and roles; Mark price and liquidation protection; dYdX oracle vs index usage; Hyperliquid mark price methodology; GMX oracle price usage.