---
title: "How to off-ramp USDC to GBP over UK Faster Payments: bank details, quotes, and timing"
seoTitle: "How to off-ramp USDC to GBP over Faster Payments"
description: "Turn USDC into pounds in a UK bank account over Faster Payments: sort code details, quotes in USDC or GBP, quote windows, timing, and a worked example."
date: "2026-10-14"
updated: "2026-10-14"
category: "payments"
author: "BlindPay Team"
howto:
  name: "How to off-ramp USDC to GBP over UK Faster Payments"
  steps:
    - name: "Add the recipient's UK bank account"
      text: "Create a faster_payments bank account with the beneficiary's legal name, a 6-digit sort code, an 8-digit account number, account class (individual or business), and address. Save the ba_ id it returns."
    - name: "Request a payout quote in USDC or in GBP"
      text: "Call the quotes endpoint with the bank account id, token USDC, the funding network, cover_fees, and currency_type: sender to fix the USDC you send, or receiver to fix the pounds that arrive. Amounts are in minor units."
    - name: "Show the amount and read expires_at"
      text: "Display receiver_amount and the fee lines, and count down from expires_at, which is in epoch milliseconds. Faster Payments quotes can expire sooner than the usual 5 minutes, so never hardcode the window."
    - name: "Authorize and execute before the quote expires"
      text: "For an external EVM wallet, approve the quoted amount using the contract payload in the quote, then create the payout with the quote_id and sender wallet address. A managed wallet skips the approval."
    - name: "Track the payout to the UK account"
      text: "Listen for payout.new, payout.update, and payout.complete webhooks. BlindPay estimates about 1 business day for a Faster Payments payout, and a failed payout fires payout.update rather than payout.complete."
faq:
  - q: "Can I convert USDC to GBP and send it to a UK bank account?"
    a: "Yes. BlindPay pays GBP to UK bank accounts over Faster Payments. You add the recipient's sort code and 8-digit account number, request a payout quote funded in USDC, and execute it before the quote expires. Individual and business beneficiaries are both supported, and the account can belong to a third party."
  - q: "How long does a USDC to GBP payout take?"
    a: "BlindPay's documented estimate is about 1 business day for a Faster Payments payout. The Faster Payments scheme itself is real-time and runs day and night, 365 days a year, according to Pay.UK. High volumes can affect delivery estimates, so track each payout through webhooks instead of promising a fixed minute."
  - q: "Can I make sure the recipient gets an exact amount in pounds?"
    a: "Yes. Create the quote with currency_type set to receiver and request_amount in pence, so 250000 means 2,500.00 GBP. The quote returns the USDC you need to send. Set cover_fees to true if the sender should pay the fees on top, so the full pound amount lands."
  - q: "Which blockchains can fund a GBP payout?"
    a: "GBP payouts are funded in USDC. An offramp wallet linked to a UK account accepts deposits on Ethereum, Base, Arbitrum, Polygon, and Solana. Whatever network you fund from, the crypto leg of a Faster Payments payout runs on Polygon, which can affect the on-chain timing you observe but not your API call."
  - q: "Why did my GBP quote expire in less than 5 minutes?"
    a: "BlindPay quotes default to 5 minutes, but Faster Payments payout quotes can be shorter because the underlying rail's own deadline can be tighter. Read expires_at from every response, show a countdown from it, and request a fresh quote when it passes. An expired quote is rejected, never executed at a new rate."
---

To off-ramp USDC to GBP, add the recipient's UK bank account (6-digit sort code, 8-digit account number), request a payout quote in USDC or in pounds, and execute it before the quote expires. The USDC converts to GBP and is paid out over Faster Payments, the UK's real-time bank rail. BlindPay estimates about 1 business day end to end.

This is the UK version of the [USDC to euros over SEPA guide](/resources/more/how-to-off-ramp-usdc-to-euros-sepa). Same quote-then-execute pattern, different bank details, and one quirk in the quote window worth knowing before you build the screen.

**Key takeaways**

- Faster Payments pays GBP to UK accounts identified by a sort code and an 8-digit account number.
- GBP payouts are funded in USDC. The crypto leg always runs on Polygon, whatever network you fund from.
- Quote in USDC (`currency_type: sender`) or in pounds (`currency_type: receiver`) to fix the amount that lands.
- Faster Payments quotes can expire sooner than 5 minutes. Read `expires_at`, never hardcode it.
- BlindPay's estimate is about 1 business day per payout. Individual and business beneficiaries are both supported.

## What is Faster Payments?

Faster Payments is the UK's real-time interbank payment system, run by Pay.UK. Pay.UK says it has operated since 2008, is "available day and night, 365 days per year", and supports real-time payments of up to £1 million, with individual banks setting their own lower limits ([Pay.UK](https://www.wearepay.uk/what-we-do/payment-systems/faster-payment-system/)).

It is also enormous. In 2025 it processed 5.55 billion transactions worth £4.84 trillion, per the same page. For a business paying UK contractors, suppliers, or customers, it is the default rail for pounds.

Faster Payments sits next to Pix, SPEI, and RTP in the family of instant domestic rails. [Instant payment systems by country](/resources/more/instant-payment-systems-by-country) compares their hours and limits.

## What do you need before the first GBP payout?

You need a customer that has passed KYC and a bank account of type `faster_payments` for the recipient. The required fields, from BlindPay's [bank accounts docs](/docs/bank-accounts):

| Field | Format | Notes |
| --- | --- | --- |
| `name` | Text | Your display name for the account |
| `account_class` | `individual` or `business` | Both beneficiary types are supported |
| `faster_payments_sort_code` | 6 digits | Dashes and spaces are stripped |
| `faster_payments_account_number` | 8 digits | UK account number |
| `faster_payments_beneficiary_legal_name` | Text | The account holder's legal name |
| `faster_payments_beneficiary_address_line_1` | Text | Beneficiary address |
| `faster_payments_beneficiary_city` | Text | Beneficiary city |
| `faster_payments_beneficiary_country` | `GB` | Country code |

Address line 2, state or region, and postal code are optional. The account can belong to someone other than your customer: set `recipient_relationship` to a value other than `first_party`, for example `vendor_or_supplier` or `independent_contractor`.

Get the legal name exactly right. UK banks run Confirmation of Payee, an account name check that Pay.UK says completes more than 2 million checks a day ([Pay.UK](https://www.wearepay.uk/what-we-do/overlay-services/confirmation-of-payee/)). The stakes are on the bank side too: since 7 October 2024, UK providers must reimburse in-scope APP scam victims on Faster Payments up to £85,000 per claim ([Payment Systems Regulator](https://www.psr.org.uk/information-for-consumers/app-fraud-reimbursement-protections/)), so name checks are taken seriously. [Verification of payee for instant payments](/resources/more/verification-of-payee-instant-payments) covers how those checks work.

## How do you send USDC to a UK bank account, step by step?

Five steps, the same shape as every BlindPay payout.

1. **Add the bank account.** `POST /v1/instances/{instance_id}/customers/{customer_id}/bank-accounts` with `type: "faster_payments"` and the fields above. Save the `ba_...` id.
2. **Request a payout quote.** `POST /v1/instances/{instance_id}/quotes` with `bank_account_id`, `token: "USDC"`, the `network` you fund from, `cover_fees`, `currency_type`, and `request_amount` in minor units ([payout quotes](/docs/payout-quotes)).
3. **Show the numbers and start the countdown.** Display `receiver_amount`, the fee lines, and a timer counting down to `expires_at` (epoch milliseconds).
4. **Authorize and execute.** From an external EVM wallet, call `approve` on the token contract with the `contract` payload from the quote, then `POST /v1/instances/{instance_id}/payouts/evm` with `quote_id` and `sender_wallet_address`. A managed wallet skips the approval.
5. **Track it.** `payout.new` fires when the payout is created and the funds are captured, `payout.update` on intermediate steps, and `payout.complete` when it is confirmed at the destination or refunded ([webhook events](/docs/learn/webhooks-events)).

There is also a no-quote path. An [offramp wallet](/docs/offramp-wallets) is a deposit address linked to the UK bank account: any USDC sent to it converts and pays out automatically. For Faster Payments accounts it accepts deposits on Ethereum, Base, Arbitrum, Polygon, and Solana. [What an off-ramp wallet is](/resources/more/what-is-an-off-ramp-wallet) covers when that beats a quote.

## Can you fix the exact amount the recipient receives in pounds?

Yes. Set `currency_type` to `receiver` and pass the pound amount in pence. The quote works backwards and tells you how much USDC to send. [Paying an exact local amount with receiver-side quotes](/resources/more/pay-exact-local-amount-receiver-side-quote) goes deeper on when to fix which side.

Illustrative example. A UK contractor invoices £2,500.00 and must receive exactly that.

| Line | Value |
| --- | --- |
| `request_amount` | 250000 (£2,500.00 in pence) |
| `commercial_quotation` (market rate) | 0.7450 GBP per USDC |
| `blindpay_quotation` (rate after BlindPay's margin) | 0.7413 GBP per USDC |
| FX margin | (0.7450 - 0.7413) / 0.7450 = 0.50% |
| USDC needed at the quoted rate | 2,500 / 0.7413 = 3,372.46 USDC |
| Flat fee, paid by the sender (`cover_fees: true`) | 2.00 USDC |
| `sender_amount` | 3,374.46 USDC |
| `receiver_amount` | £2,500.00 |

At the pure market rate the same £2,500 would cost 2,500 / 0.7450 = 3,355.70 USDC. The 18.76 USDC difference is the full cost of this payout: 16.76 in the rate plus the 2.00 flat fee, about 0.56% all in. [Cost per delivered dollar](/resources/more/cost-per-delivered-dollar) shows how to compare that number across providers.

The quote does this math for you. Read `sender_amount` from the response instead of computing it yourself, because fee rounding and minimums are applied server side.

Faster Payments payouts also carry a minimum per payout, set on the USDC side when you quote by sender amount and on the pound side when you quote by receiver amount. Below it, the quote fails with an error naming the side you missed. Current figures are in the [payouts docs](/docs/payouts).

## Which networks and tokens can fund a GBP payout?

GBP payouts are funded in USDC. The quote is priced for the `network` you send from, and BlindPay's [supported chains](/docs/kb/supported-chains) reference lists where USDC is deployed.

The detail that surprises people: the crypto leg of a Faster Payments payout always runs on Polygon, regardless of the network you funded from ([payment methods](/docs/kb/payment-methods)). That changes nothing in your API call. It can change the on-chain timing you see between funding and the bank send.

If you use an offramp wallet instead of quotes, pick one of the five deposit networks above. [Which network to use to off-ramp stablecoins](/resources/more/best-network-to-off-ramp-stablecoins) compares finality and fees by chain.

## How long does a GBP payout take?

BlindPay's documented estimate is about 1 business day for Faster Payments, and high transaction volumes can affect that estimate ([bank accounts docs](/docs/bank-accounts)). The Faster Payments rail itself is real-time. The estimate covers the whole payout through BlindPay's banking partner network, not just the final bank credit.

| Stage | What happens | Timing |
| --- | --- | --- |
| Quote | Rate and fees locked | Up to 5 minutes, often shorter on this rail |
| Execute | USDC pulled from the funding wallet | One on-chain confirmation |
| Conversion and bank send | USDC to GBP, paid over Faster Payments | Part of the ~1 business day estimate |
| Credit | Pounds land in the UK account | Status moves to completed |

Promise your users "about 1 business day", then update them from webhooks. [How to track an off-ramp payout](/resources/more/how-to-track-a-crypto-off-ramp-payout) has a status-to-message map you can reuse.

## Why can a GBP quote expire sooner than 5 minutes?

Because the rail's own deadline can be tighter than BlindPay's default. Every BlindPay quote defaults to 5 minutes, and the [cut-off times reference](/docs/kb/cut-off-times) notes that SEPA and Faster Payments payout quotes may be shorter.

In practice that means three rules for your code:

1. Read `expires_at` from the response. It is epoch milliseconds, not seconds.
2. Request the quote on the confirmation screen, not two screens earlier.
3. When the timer hits zero, re-quote and show the new numbers. An expired quote is rejected, never executed at a different rate.

[Handling expired quotes in TypeScript and Python](/resources/more/handle-expired-quotes-typescript-python) has the full retry loop, and [who carries FX risk in a stablecoin payout](/resources/more/who-carries-fx-risk-stablecoin-payout) explains why short windows exist at all.

## What does a GBP payout cost?

Every cost is in the quote before you execute. `commercial_quotation` next to `blindpay_quotation` shows the FX margin, `flat_fee` shows the fixed part, and `partner_fee_amount` shows any markup your platform adds ([partner fees on live quotes](/resources/more/partner-fees-markup-on-live-quotes)).

BlindPay combines a monthly plan with per-transaction fees that vary by rail and network and are disclosed in the live quote before execute. There is no static rate card. Owners and admins can read the Faster Payments fee object for their instance from `GET /v1/instances/{instance_id}/billing/fees` ([billing](/docs/learn/billing)). Plans are on the [pricing page](/pricing).

To judge whether the price is good, the [on/off-ramp liquidity scorecard](/resources/more/onramp-offramp-liquidity-scorecard) and the [liquidity glossary](/resources/more/onramp-offramp-liquidity-glossary) give you the terms and the tests.

## What to do next

Create a `faster_payments` bank account on a development instance, request one receiver-side quote for £2,500, and check how `expires_at` compares with the 5-minute default. The [bank accounts docs](/docs/bank-accounts) have the exact request body.