Reference Currency Converter

This tool performs bi-directional currency conversion for six major currencies: USD (US Dollar), EUR (Euro), JPY (Japanese Yen), GBP (British Pound), CNY (Chinese Yuan), and AUD (Australian Dollar).

The input amount field accepts only finite numbers between 0 and 1,000,000,000,000 inclusive. Empty fields, unparseable non-numeric characters, negative numbers, exponential inputs resulting in Infinity, and values exceeding the maximum limit are validated individually, displaying error messages associated with the input field.

Because 0 is treated as a valid amount, empty inputs and 0 are clearly distinguished. While an input is invalid, the primary conversion result displays a dash, preventing erroneous figures from being shown.

Source and target currencies can each be selected independently, and pressing the swap button in the center reverses the conversion direction without altering the entered numeric amount.

For example, if you swap while viewing 100 USD converted to JPY, the input of 100 remains and is converted as 100 JPY into USD. Because this does not automatically transcribe the previous conversion result into the new input field, care should be taken that the numerical premise changes when comparing round trips.

An accessible label is also provided for assistive technology on the swap button.

In addition to the primary result, the interface presents a quick reference table converting 1, 10, 100, and 1,000 units in both directions for the selected currency pair.

Furthermore, a 6×6 cross-rate matrix displays 1 unit of each row currency converted into each column currency across all six currencies.

Changes in the input amount update the primary result, while the quick reference table shows the four fixed denominations and the matrix displays single-unit ratios.

When currency selections or active exchange rates change, the primary result and both tables recalculate from the same underlying rate set.

Tables include captions, column headers, and row headers, and can be scrolled horizontally on narrow viewports.

On page load and when clicking the refresh button, the browser issues an HTTP GET request to the ExchangeRate-API Open Access endpoint at https://open.er-api.com/v6/latest/USD.

This URL is fixed to a USD base and does not append the entered amount or chosen source and target currencies to query parameters or request body.

Data from Open Access is a reference rate updated roughly once per day, rather than a mechanism fetching second-by-second foreign exchange quotes upon each button press.

The screen identifies the data as an "API-Provided Rate" and provides an attribution link to the provider site via "Rates By Exchange Rate API."

Received JSON responses are not adopted solely on HTTP success status. The application validates that result equals success, base_code is USD, and rates is an object containing positive finite numbers for all six currencies: USD, EUR, JPY, GBP, CNY, and AUD.

It further verifies that time_last_update_unix is a positive safe integer, and applies the same checks to time_next_update_unix when present.

If any currency is missing, returned as a string, contains zero, negative values, NaN, or Infinity, or exhibits an invalid timestamp, the entire response is rejected.

Because valid items are never partially merged with static or historical values, the six displayed currencies are always treated as a single unified set from one response.

The provider's last updated Unix timestamp is converted and displayed in Asia/Tokyo Japan Standard Time using Intl.DateTimeFormat.

This reflects the timestamp of the exchange rate data indicated by the API, rather than the moment the browser received the response.

Fetch operations implement a 10-second timeout with an AbortController, aborting pending requests when navigating away from the component.

Request generation IDs are also checked to prevent older requests from overwriting newer state upon completion. However, cancellation controls do not guarantee provider uptime, network success, or rate freshness.

In-flight fetching, active source, and error states are differentiated via on-screen indicators and live regions.

Both the API and static reference data represent a USD-base rate set describing how much one USD is worth in each currency. For any arbitrary currency pair, the source amount is divided by the source currency's USD-base rate to normalize it into USD, and that figure is then multiplied by the target currency's USD-base rate.

The formula is: Converted Amount = Input Amount ÷ Source Rate against USD × Target Rate against USD. Rather than storing 36 direct pair rates or searching multi-hop paths, all combinations among the six currencies are computed via this identical two-step formula.

If conversion calculations overflow due to excessively large finite rates, the interface renders a dash (—) rather than throwing an exception during rendering.

For example, using the static reference rates where USD = 1 and JPY = 158.5, converting 100 USD to JPY yields 100 ÷ 1 × 158.5 = 15,850 JPY.

Converting 50,000 JPY to EUR with static rates JPY = 158.5 and EUR = 0.92 yields 50,000 ÷ 158.5 in USD terms, which multiplied by 0.92 gives approximately 290.22 EUR.

These represent calculation examples using static figures and will not necessarily match results when the screen successfully retrieves API-provided rates.

When source and target currencies are identical, dividing and multiplying by the same rate leaves the converted amount equal to the input amount.

Calculations are executed using JavaScript Number types, representing IEEE 754 double-precision floating-point numbers. Dedicated arbitrary-precision decimal libraries or big integers are not utilized.

Number.isFinite validates inputs and API rates, confirming finite values after computation. While the 1 trillion input ceiling prevents excessive magnitudes, it does not eliminate minuscule rounding artifacts inherent in binary floating-point arithmetic.

Display formatting varies decimal precision depending on purpose. Converted amounts in the primary result and quick reference table are formatted using Intl.NumberFormat, showing no decimals for JPY and two decimal places for the other five currencies.

Unit rates are uniformly formatted to four decimal places using toFixed(4), while the cross-rate matrix displays two decimal places for values of 100 or greater and four decimal places for values below 100.

Because Intl.NumberFormat and toFixed return display strings rather than overwriting internal computational values, manual calculations using only screen-rounded figures may differ slightly in terminal digits from displays calculated from internal precision.

The interface initially begins fetching from the API while displaying hardcoded static reference values: USD = 1, EUR = 0.92, JPY = 158.5, GBP = 0.79, CNY = 7.26, and AUD = 1.5.

These six values serve as static baselines allowing users to inspect the interface before network completion; they do not represent fetch timestamps, current market rates, or executable trading prices.

Only after the initial API fetch succeeds and passes all response validation checks—including rejecting payloads whose Unix epoch timestamp exceeds the representable range of a JavaScript Date object—are all six currencies simultaneously replaced with API-provided rates along with the provider's timestamp.

If the initial fetch fails due to network failure, HTTP errors, malformed JSON, missing required rates, anomalous values, or a 10-second timeout, the static reference values are retained, with on-screen notices indicating static values are in use and the fetch failed.

If a manual refresh fails after API rates have already been retrieved, the previously valid API rates residing in that tab's memory are preserved rather than discarded.

The failed response is not partially blended, and an error message clarifies that previous rates remain active. While users can retry via the refresh button, the button is disabled during processing to prevent duplicate submissions.

This tool does not maintain persistent rate caches in localStorage, IndexedDB, or server-side databases. Retention of previous API values is limited strictly to the React state of the currently open page.

Reloading the page resets to static reference values and initiates a new API fetch. Static reference values are not claimed as an "offline guarantee," nor is uninterrupted availability without initial page loading or external APIs guaranteed.

Rather than burying errors in developer consoles, visible statuses clarify whether displayed rates are API-derived or static, and whether refreshes have failed.

ExchangeRate-API describes its values as synthetic reference mid-market exchange rates compiled from multiple data sources. Open Access figures are updated roughly once every 24 hours and do not broadcast continuous bid and ask fluctuations from foreign exchange markets.

They cannot be equated with bank telegraphic transfer middle rates (TTM) fixed at specific times, retail TTS or TTB quotes from financial institutions, over-the-counter bureau de change prices, or actionable quotes executable on FX platforms.

Consequently, while retaining search terms in page headings, both the interface and text explicitly characterize rates as "API-Provided Rates," "Reference Only," and "Updated roughly once per day."

Displayed figures exclude bid/ask spreads, foreign exchange commissions from banks and currency booths, foreign transaction fees levied by credit card issuers, card network conversion terms, overseas remittance fees, recipient charges, taxes, delivery costs, and customs duties.

Furthermore, calculations do not model rate shifts arising from timing discrepancies between transaction time and card settlement, or between remittance instructions and receipt of funds.

For instance, a reference conversion of 100 USD to 15,000 JPY does not imply a credit card statement will charge exactly 15,000 JPY.

Final amounts must be verified through the definitive terms of the bank, card issuer, remittance service, or merchant involved.

This tool does not forecast future rates, detect market anomalies, recommend exchange timing, compute foreign exchange gains or losses, provide accounting exchange rates, or assist in hedging decisions.

While useful for estimating travel budgets, assessing price scales across currencies, or preliminary comparisons against merchant quotes under uniform conditions, it cannot serve as documentation for financial advice, FX trading, tax returns, or corporate accounting.

When records are required, document the timestamp and rate source, and verify figures against official materials prescribed by financial institutions or accounting professionals.

Entered amounts, source currencies, and target currencies are maintained in browser memory as React state on the current page, and conversion formulas execute entirely in client-side JavaScript.

The GET request sent to the fixed API URL does not include entered amounts or selected currency pairs in its query parameters or body.

Amounts are not transmitted to or stored in ZeroTools proprietary conversion APIs or databases, and reloading the page restores input and selection states to default values.

However, external communication to fetch exchange rates does take place. When the browser connects to ExchangeRate-API, HTTP metadata such as client IP address, Origin, User-Agent, and Referer headers may be transmitted to the API provider or content delivery networks.

This tool cannot determine what connection data is retained on provider infrastructure. Therefore, the fact that entered amounts are excluded from requests to the fixed USD URL is explained separately from the existence of network communication.

Terms such as fully local, completely offline, or zero external transmission are not used.

When transcribing results into notes or documentation, recording the currency pair, source amount, provider timestamp shown on screen, and whether rates were API-provided or static reference values ensures premises remain verifiable later.

If static reference values were in effect, do not treat them as records of prevailing market prices; even with API rates, distinguish them from actual settlement terms.

Differentiating execution environment, external network calls, rate origins, display rounding, and commercial transaction differences allows this tool to be used reproducibly within its reference conversion scope.