Why is the rate on Google different from my off-ramp quote?

The rate on Google is a delayed mid-market reference: the midpoint between wholesale buy and sell prices, shown for information. An off-ramp quote is a price you can actually execute, on one side of the market, with the provider's spread, fees, and risk for the quote window built in. So the two rarely match, and they shouldn't.

The useful question isn't "why is it different?" It's "how much of the difference is fair?" This guide splits the gap into its parts, shows the arithmetic on a USDC to BRL payout, and gives a rule for when a gap is a red flag.

Key takeaways

• Google shows currency prices from a data provider with a short delay, and says to confirm rates before you transact.
• The mid-market rate is a reference. Nobody executes at the midpoint for free.
• An off-ramp quote differs because of side of the market, spread, fees, timing, and the risk of holding the price for a window.
• Measure the gap in basis points, captured in the same minute, against the amount that actually lands.
• On a BlindPay quote, commercial_quotation vs blindpay_quotation shows the provider's cost before you send.

What rate does Google actually show?

A mid-market reference rate, slightly delayed. Google's finance data disclaimer says currency prices are provided by Morningstar, lists a delay of 3 minutes for currencies, and states that "Google cannot guarantee the accuracy of the exchange rates displayed. You should confirm current rates before making any transactions."

The mid-market rate is the midpoint between the price buyers bid and the price sellers ask in the wholesale market. Wise's guide to the mid-market rate describes it the same way, and notes it is the rate you see when you search a currency pair online. The glossary for this cluster uses the same definition.

Two words matter there: midpoint and reference. A midpoint is not a price anyone sells at. A reference is not a commitment. Central banks say this out loud: the ECB publishes its euro reference rates around 16:00 CET each working day "for information purposes only" and strongly discourages using them for transactions.

Why doesn't an off-ramp quote match the Google rate?

Because a quote is a price you can execute, and executing has costs that a reference rate doesn't carry. Six things open the gap:

None of these is a trick on its own. The first three are the cost of the service. The last three are physics: markets move, and depth is finite. Why buy and sell rates differ at all is covered in why on-ramp and off-ramp rates differ.

What would be a problem is a gap you can't see. A provider that shows an indicative rate and settles later at a worse one adds a seventh source: slippage, which you never agreed to. The FX slippage guide shows how to spot it.

How do you measure the gap fairly?

Measure it in basis points, against the same minute, on the amount that actually lands. One basis point is 0.01%.

1. Open the reference and request the quote in the same minute. A 3-minute delay on a volatile day is enough to move BRL by several basis points.
2. Compare the quote's market rate to the reference. At BlindPay that's commercial_quotation, the raw market rate when the quote was created. A small gap here is data timing, not margin.
3. Compare the rate after fees to the market rate. That's blindpay_quotation against commercial_quotation. This is the provider's cost on the conversion.
4. Check the delivered amount. receiver_amount is what the bank account gets, in minor units. It's the only number the recipient cares about.

The formula for each step:

gap_bps = (reference rate - effective rate) / reference rate x 10,000

Illustrative example. You off-ramp 1,000 USDC to BRL. All numbers are made up for the arithmetic.

• Timing and data gap: (5.4000 - 5.3980) / 5.4000 x 10,000 = about 3.7 bps
• Provider cost: (5.3980 - 5.3710) / 5.3980 x 10,000 = about 50 bps
• All-in gap vs Google: (5,400.00 - 5,371.00) / 5,400.00 x 10,000 = about 53.7 bps, or R$29 on this payout

Split this way, the R$29 stops being a mystery. About R$2 is the reference being a few minutes old. About R$27 is the price of the conversion, shown before you sent anything. To put that 50 bps in context across a whole payout, stablecoin off-ramp fees explained compares per-transaction costs with a bank wire.

Which reference rate should a finance team use?

It depends on the job. Pick one per job and write it down, so nobody argues about it at month end.

The quote's own market rate has one big advantage: it's timestamped to the exact quote. The other two are fine references, just not for a payout you priced at a specific minute.

When is the gap a red flag?

When you can't see where it comes from. Three patterns are worth a closer look:

• The "market rate" is far from the public reference in the same minute. A few basis points is timing. A wide, persistent gap on a liquid pair means the market rate itself may already carry margin.
• The rate settles worse than shown. That's slippage. On a binding quote executed inside its window, it should be zero.
• No itemized fees. If the only number is a rate, you can't split margin from fees, and comparing providers becomes guesswork.

Decision rule: compare providers on delivered amount, captured in the same minute, for the same size. A quote that looks worse on rate can land more money if its fees are lower. The USDC to BRL routes guide compares the paths a dollar takes into reais.

What does the Google rate get right?

Plenty. It's free, it's everywhere, and it tells you the direction and the rough level of a currency at a glance. If your quote is 5% away from Google on USD to BRL, something is wrong, and Google is how you notice.

Just don't treat it as a price. The USDC to BRL corridor page shows an indicative rate for the same reason Google does: orientation, not execution.

What to do next

Request a payout quote for your corridor, open Google in the same minute, and run the three-step split above. If the provider cost on your corridor is a number you can live with, that's the rate you'll get, every time you execute inside the window.