Wise APIwise.com ↗
Get live Wise.com exchange rates, transfer fees, currency conversion, and historical rate data via a structured JSON API. 7 endpoints covering all major pairs.
What is the Wise API?
This API exposes 7 endpoints covering Wise.com's exchange rates, transfer fees, and currency data. Use get_exchange_rate to fetch the current mid-market rate between any two currencies along with a 48-hour percentage change, or call convert_currency to get the exact recipient amount and total fee for a specific send amount. All responses return structured JSON fields ready to consume without parsing HTML.
curl -X GET 'https://api.parse.bot/scraper/e12755f4-6de3-4592-9b84-358de36519b2/get_exchange_rate?source=USD&target=EUR' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace wise-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Wise Currency API — compare transfer routes, check fees, track trends."""
from parse_apis.wise_currency_api import Wise, Period, CurrencyNotFound
client = Wise()
# List supported currencies and print a few
for cs in client.currencysummaries.list(limit=3):
print(cs.code, cs.name, cs.symbol)
# Get full details for USD, including exchange rate table
usd = client.currencies.get(code="USD")
print(usd.name, usd.symbol, usd.description[:60])
for entry in usd.exchange_rate_table[:2]:
print(f" {entry.currency}: from={entry.from_rate} to={entry.to_rate}")
# Check available conversion pairs from USD
pair_info = usd.pairs()
print(f"{pair_info.base_currency} has {len(pair_info.available_pairs)} pairs")
# Get live exchange rate USD → EUR
rate = client.exchangerates.get(source="USD", target="EUR")
print(f"Rate: {rate.mid_market_rate}, 48h change: {rate.percentage_change_48h}%")
# Get historical rate data for the last week
history = client.exchangerates.history(source="USD", target="EUR", period=Period.ONE_WEEK)
print(f"Period {history.period}: current={history.current_rate}, change={history.percentage_change}%")
dp = history.data_points[0]
print(f" First point: value={dp.value}, time={dp.time}")
# Convert 5000 USD → EUR and inspect fees
conversion = client.conversions.get(source="USD", target="EUR", amount=5000)
print(f"Send {conversion.amount_entered} {conversion.source_currency}")
print(f"Recipient gets {conversion.recipient_receives} {conversion.target_currency}, fee={conversion.total_fee}")
# Get full fee breakdown across payment methods
fees = client.transferfees.get(source="USD", target="EUR", amount=5000)
for opt in fees.pricing_options[:2]:
print(f" {opt.pay_in_method}→{opt.pay_out_method}: fee={opt.total_fee}, receives={opt.recipient_amount}")
# Typed error handling for an invalid currency
try:
client.currencies.get(code="ZZZZZ")
except CurrencyNotFound as exc:
print(f"Error: currency '{exc.code}' not found")
print("Exercised: currencysummaries.list, currencies.get, pairs, exchangerates.get, history, conversions.get, transferfees.get")
Get the current mid-market exchange rate between two currencies. Returns the live rate, a 48-hour percentage change, and the timestamp. Useful for spot-checking rates before initiating a transfer.
| Param | Type | Description |
|---|---|---|
| sourcerequired | string | Source currency code (e.g. USD, GBP, EUR) |
| targetrequired | string | Target currency code (e.g. EUR, USD, GBP) |
{
"type": "object",
"fields": {
"timestamp": "integer — Unix timestamp in milliseconds of the rate",
"mid_market_rate": "number — current mid-market exchange rate",
"source_currency": "string — source currency code",
"target_currency": "string — target currency code",
"percentage_change_48h": "number — percentage change over last 48 hours",
"rate_guarantee_duration": "string — description of rate guarantee duration"
},
"sample": {
"data": {
"timestamp": 1781148615093,
"mid_market_rate": 0.865988,
"source_currency": "USD",
"target_currency": "EUR",
"percentage_change_48h": -0.0823,
"rate_guarantee_duration": "Usually 24-48 hours depending on the route"
},
"status": "success"
}
}About the Wise API
Exchange Rates and Conversion
The get_exchange_rate endpoint takes a source and target currency code and returns the current mid-market rate (mid_market_rate), a Unix millisecond timestamp, and percentage_change_48h — useful for displaying rate movement to users. The convert_currency endpoint adds fee context: given an amount, source, and target, it returns recipient_receives, total_fee, pay_in_method, pay_out_method, and potential_savings (the estimated savings versus a traditional bank, or null if unavailable).
Transfer Fees and Pricing Options
get_transfer_fee goes deeper than a single conversion quote. For a given send amount and currency pair, it returns a pricing_options array where each object covers a distinct pay_in_method and pay_out_method combination, along with total_fee, variable_fee, fixed_fee, exchange_rate, recipient_amount, and an estimate field. This lets you compare, for example, the cost difference between paying by card versus bank transfer for the same corridor.
Currency Coverage and Historical Data
list_supported_currencies returns every currency Wise supports, each record including code, symbol, name, countryKeywords, and supportsDecimals. Use get_currency_pairs with a base code to retrieve the full list of available conversion pairs as an available_pairs array. get_currency_details returns a richer record for a single currency: currency_name, currency_symbol, description, and an exchange_rate_table array showing from_rate and to_rate against major currencies.
Historical Rates
get_exchange_rate_history accepts a period parameter (1D, 1W, 1M, 6M, 1Y, or 5Y) plus source and target codes. It returns a data_points array of timestamped rate objects, the current_rate, and a percentage_change over the selected window — enough to render a simple rate chart or build a volatility signal.
The Wise API is a managed, monitored endpoint for wise.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when wise.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official wise.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Display live mid-market rates and 48-hour movement in a currency converter widget using
get_exchange_rate. - Compare transfer costs across pay-in and pay-out method combinations using the
pricing_optionsarray fromget_transfer_fee. - Show users how much a recipient will receive after fees for a given send amount using
convert_currency. - Render a historical rate chart for any currency pair over 1D to 5Y periods using
get_exchange_rate_historydata points. - Populate a currency selector dropdown with codes, names, symbols, and decimal support flags from
list_supported_currencies. - Build a currency detail page with cross-rates to major currencies using the
exchange_rate_tablefromget_currency_details. - Check which target currencies are available for a given base currency before presenting transfer options using
get_currency_pairs.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Wise have an official developer API?+
What does `get_transfer_fee` return that `convert_currency` does not?+
get_transfer_fee returns a pricing_options array covering multiple pay-in and pay-out method combinations in a single call. Each entry breaks the fee into variable_fee and fixed_fee components, so you can see the cost structure for bank transfer versus card versus other methods side by side. convert_currency returns a single quote for the default method combination along with a potential_savings estimate.How fresh is the exchange rate data?+
get_exchange_rate response includes a timestamp field in Unix milliseconds reflecting when the rate was recorded. Wise updates its mid-market rates continuously during market hours, but the exact refresh cadence visible through the API depends on when the underlying rate data is updated on Wise's public pages. For time-sensitive applications, re-query frequently and compare timestamp values.Does the API expose Wise account balances, transaction history, or recipient details?+
Can I retrieve exchange rates for exotic or less common currency pairs?+
get_currency_pairs with your base code to check which target currencies are available before querying rates or fees. list_supported_currencies gives the full set of currency codes Wise recognizes, though not every combination has an active transfer corridor. If a corridor you need is missing, you can fork the API on Parse and revise it to surface additional data points.