Multi-currency price display

A currency switcher lets guests browse prices in a currency they know, even when the property sells in another one. The Best Price API returns prices in the property’s currency and does not convert them, so the conversion layer belongs to your interface. This page shows how to build it.

Prerequisites

Before building the conversion layer, make sure you have:

A working Best Price call. If not, follow the Quick start first.
A hotel ID and a group ID for the property you display.
A public source of daily exchange rates. The European Central Bank reference rates are free, published every working day, and cover the main currencies.

How it works

The API returns every offer in the currency the property sells in. filter.currency selects, it does not convert: when a property sells in several currencies, the filter picks which one you receive. Requesting a currency the property does not sell in returns an empty response, not converted prices.

A guest browsing in EUR on a GBP-only property sees an empty calendar if you pass the guest’s currency to the API. Keep the API currency and the display currency as two separate settings.

The pattern is one call in the property’s currency, a daily exchange rate feed on the side, and a conversion at display time. The converted amount is indicative: the booking and the payment always happen in the property’s currency.

Build the conversion layer

The examples below assume the OAuth signing setup from the Quick start.

Request prices in the property's currency

Set filter.currency to the currency the property sells in. If you do not know it yet, omit the filter on the first call, at a small performance cost: the service then uses the property’s most used currency, and every response entry carries its currency.

curl --request POST \
  --url https://{apiBaseUrl}/Planning/2018A/BestPrice/Calendar \
  --header 'Authorization: OAuth ...' \
  --header 'Content-Type: application/json' \
  --data '{
    "beginDate": "2026-12-07",
    "endDate": "2027-01-05",
    "guests": [{"adults": 2}],
    "filter": {
      "ratePlan": {"hotelId": <hotelId>, "groupId": <groupId>},
      "currency": "GBP"
    }
  }'

const url = "https://{apiBaseUrl}/Planning/2018A/BestPrice/Calendar";

const response = await fetch(url, {
  method: "POST",
  headers: { ...authHeaders, "Content-Type": "application/json" },
  body: JSON.stringify({
    beginDate: "2026-12-07",
    endDate: "2027-01-05",
    guests: [{ adults: 2 }],
    filter: {
      ratePlan: { hotelId: <hotelId>, groupId: <groupId> },
      currency: "GBP",
    },
  }),
});
const data = await response.json();

response = session.post(
    "https://{apiBaseUrl}/Planning/2018A/BestPrice/Calendar",
    json={
        "beginDate": "2026-12-07",
        "endDate": "2027-01-05",
        "guests": [{"adults": 2}],
        "filter": {
            "ratePlan": {"hotelId": <hotelId>, "groupId": <groupId>},
            "currency": "GBP",
        },
    },
)
data = response.json()

$response = $client->post('Planning/2018A/BestPrice/Calendar', [
    'json' => [
        'beginDate' => '2026-12-07',
        'endDate'   => '2027-01-05',
        'guests'    => [['adults' => 2]],
        'filter'    => [
            'ratePlan' => ['hotelId' => <hotelId>, 'groupId' => <groupId>],
            'currency' => 'GBP',
        ],
    ],
]);
$data = json_decode($response->getBody(), true);

var request = new RestRequest("/BestPrice/Calendar", Method.Post);
request.AddJsonBody(new
{
    beginDate = "2026-12-07",
    endDate = "2027-01-05",
    guests = new[] { new { adults = 2 } },
    filter = new
    {
        ratePlan = new { hotelId = <hotelId>, groupId = <groupId> },
        currency = "GBP"
    }
});

var response = await client.ExecuteAsync(request);
var data = JsonDocument.Parse(response.Content!).RootElement;

String body = mapper.writeValueAsString(Map.of(
    "beginDate", "2026-12-07",
    "endDate", "2027-01-05",
    "guests", List.of(Map.of("adults", 2)),
    "filter", Map.of(
        "ratePlan", Map.of("hotelId", <hotelId>, "groupId", <groupId>),
        "currency", "GBP"
    )
));

HttpPost request = new HttpPost("https://{apiBaseUrl}/Planning/2018A/BestPrice/Calendar");
request.setEntity(new StringEntity(body, "UTF-8"));
request.setHeader("Content-Type", "application/json");
consumer.sign(request);

JsonNode data;
try (CloseableHttpResponse response = client.execute(request)) {
    data = mapper.readTree(EntityUtils.toString(response.getEntity()));
}

Fetch the daily exchange rates

Load the reference rates once a day from your source and cache them. The examples below parse the ECB daily feed into a map of units per euro, with EUR as the pivot.

const ECB_URL = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml";

async function fetchDailyRates() {
  const xml = await (await fetch(ECB_URL)).text();
  const rates = { EUR: 1 };
  for (const [, currency, rate] of xml.matchAll(/currency='([A-Z]{3})'\s+rate='([\d.]+)'/g)) {
    rates[currency] = Number(rate);
  }
  return rates; // units per euro, e.g. { EUR: 1, GBP: 0.855, USD: 1.08 }
}

import re
import requests

ECB_URL = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml"

def fetch_daily_rates():
    xml = requests.get(ECB_URL).text
    rates = {"EUR": 1.0}
    for currency, rate in re.findall(r"currency='([A-Z]{3})'\s+rate='([\d.]+)'", xml):
        rates[currency] = float(rate)
    return rates  # units per euro, e.g. {"EUR": 1, "GBP": 0.855, "USD": 1.08}

const ECB_URL = 'https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml';

function fetchDailyRates(): array
{
    $rates = ['EUR' => 1.0];
    $xml = simplexml_load_file(ECB_URL);
    foreach ($xml->Cube->Cube->Cube as $cube) {
        $rates[(string) $cube['currency']] = (float) $cube['rate'];
    }
    return $rates; // units per euro, e.g. ['EUR' => 1, 'GBP' => 0.855, 'USD' => 1.08]
}

const string EcbUrl = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml";

async Task<Dictionary<string, decimal>> FetchDailyRates()
{
    var xml = XDocument.Parse(await httpClient.GetStringAsync(EcbUrl));
    var rates = new Dictionary<string, decimal> { ["EUR"] = 1m };
    foreach (var cube in xml.Descendants().Where(e => e.Attribute("currency") != null))
    {
        rates[cube.Attribute("currency")!.Value] =
            decimal.Parse(cube.Attribute("rate")!.Value, CultureInfo.InvariantCulture);
    }
    return rates; // units per euro, e.g. EUR = 1, GBP = 0.855, USD = 1.08
}

String ECB_URL = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml";

Map<String, Double> fetchDailyRates() throws Exception {
    String xml = new String(new URL(ECB_URL).openStream().readAllBytes(), StandardCharsets.UTF_8);
    Map<String, Double> rates = new HashMap<>();
    rates.put("EUR", 1.0);
    Matcher m = Pattern.compile("currency='([A-Z]{3})'\\s+rate='([\\d.]+)'").matcher(xml);
    while (m.find()) {
        rates.put(m.group(1), Double.parseDouble(m.group(2)));
    }
    return rates; // units per euro, e.g. EUR = 1, GBP = 0.855, USD = 1.08
}

Convert at display time

Convert each price from the currency carried by the response entry to the currency the guest picked, then round for display. Always convert from the exact amount the API returned, and keep that amount untouched for the booking hand-off.

function convertAmount(amount, source, target, rates) {
  return amount * (rates[target] / rates[source]);
}

data.forEach(day => {
  if (day.status === "Available") {
    const displayPrice = convertAmount(day.totalPrice, day.currency, guestCurrency, rates);
    renderCell(day.arrivalDate, {
      price: `≈ ${displayPrice.toFixed(0)} ${guestCurrency}`,
    });
  }
});

def convert_amount(amount, source, target, rates):
    return amount * rates[target] / rates[source]

for day in data:
    if day["status"] == "Available":
        display_price = convert_amount(day["totalPrice"], day["currency"], guest_currency, rates)
        render_cell(day["arrivalDate"], {"price": f"≈ {display_price:.0f} {guest_currency}"})

function convertAmount(float $amount, string $source, string $target, array $rates): float
{
    return $amount * $rates[$target] / $rates[$source];
}

foreach ($data as $day) {
    if ($day['status'] === 'Available') {
        $displayPrice = convertAmount($day['totalPrice'], $day['currency'], $guestCurrency, $rates);
        renderCell($day['arrivalDate'], [
            'price' => sprintf('≈ %d %s', round($displayPrice), $guestCurrency),
        ]);
    }
}

decimal ConvertAmount(decimal amount, string source, string target, Dictionary<string, decimal> rates)
    => amount * rates[target] / rates[source];

foreach (var day in data.EnumerateArray())
{
    if (day.GetProperty("status").GetString() == "Available")
    {
        var displayPrice = ConvertAmount(
            day.GetProperty("totalPrice").GetDecimal(),
            day.GetProperty("currency").GetString()!,
            guestCurrency,
            rates);
        RenderCell(day.GetProperty("arrivalDate").GetString()!, new
        {
            price = $"≈ {Math.Round(displayPrice)} {guestCurrency}"
        });
    }
}

double convertAmount(double amount, String source, String target, Map<String, Double> rates) {
    return amount * rates.get(target) / rates.get(source);
}

for (JsonNode day : data) {
    if ("Available".equals(day.get("status").asText())) {
        double displayPrice = convertAmount(
            day.get("totalPrice").asDouble(), day.get("currency").asText(), guestCurrency, rates);
        renderCell(
            day.get("arrivalDate").asText(),
            Map.of("price", "≈ %.0f %s".formatted(displayPrice, guestCurrency))
        );
    }
}

Let the guest switch currency

A currency switch is a re-render, not a new API call. The response you already hold is in the property’s currency, so apply the new target currency to the same data. Reserve new calls for changes that affect the offer itself: dates, party, or filters.At the point where the guest commits, show the price in the property’s currency as well, since that is the amount they will pay. A short mention such as “You will be charged in GBP” avoids surprises in the booking funnel.

Tips

Keep two currency settings. The API currency belongs to the property, the display currency belongs to the guest. Sending the guest’s currency in filter.currency returns an empty response whenever the property does not sell in it, and the guest sees an empty calendar.
Refresh the rates once a day. Align the refresh with your source’s publication time (the ECB publishes around 16:00 CET on working days; weekends keep Friday’s rates). Cache the map so a source outage never blanks your prices.
Say the amount is approximate. The ≈ sign or a footnote is enough. Daily reference rates differ slightly from the rate the guest’s bank applies, and the payment is taken in the property’s currency.
Mind multi-currency properties. When a property sells in more than one currency, filter.currency picks which one you receive. Pick one and keep it stable, so your cache and your conversions stay consistent.

Dynamic price calendar

The browse experience this conversion layer usually plugs into.

Best practices

Caching, performance, and resilience patterns.

Get started

Build

Resources

Multi-currency price display

Prerequisites

How it works

Build the conversion layer

Request prices in the property's currency

Fetch the daily exchange rates

Convert at display time

Let the guest switch currency

Tips

Dynamic price calendar

Best practices

​Prerequisites

​How it works

​Build the conversion layer

Request prices in the property's currency

Fetch the daily exchange rates

Convert at display time

Let the guest switch currency

​Tips

​Related

Dynamic price calendar

Best practices

Prerequisites

How it works

Build the conversion layer

Tips

Related