DEV Community

Alper San
Alper San

Posted on • Originally published at sifting.io

How to Get Real-Time Forex Prices with REST and WebSocket

#api #data #programming #tutorial

Real-time forex data is one of the most common requirements in financial applications.

You might need it for:

  • A live EURUSD ticker
  • A currency converter
  • A pricing screen
  • A trading dashboard
  • A price alert system
  • A research or backtesting workflow

In most cases, there are two practical ways to read live FX prices:

  1. Use a REST API when you need the latest quote at a specific moment.
  2. Use a WebSocket stream when your application needs continuous updates.

This guide shows how that works with SiftingIO.

Originally published on the SiftingIO blog:
https://sifting.io/blog/how-to-get-real-time-forex-prices-from-siftingio

What real-time forex data means

Real-time forex data usually includes the latest quote for a currency pair.

For a pair like EURUSD, the most important fields are:

  • Bid: the price buyers are offering
  • Ask: the price sellers are asking
  • Mid: the midpoint between bid and ask
  • Spread: the difference between bid and ask

A real-time forex feed keeps those values updated as the market moves.

With SiftingIO, you can read forex prices through REST snapshots or WebSocket streams using the same API key and the same general data model.

Option 1: Get the latest forex quote with REST

If your application only needs the current price occasionally, a REST request is usually enough.

Example:

curl -H "X-API-Key: $SIFTING_KEY" \
  "https://api.sifting.io/v1/last/quote/forex/EURUSD"
Enter fullscreen mode Exit fullscreen mode

This returns the latest quote snapshot for EURUSD.

A REST snapshot is useful for:

  • Currency converters
  • Dashboards that refresh every few seconds
  • Scheduled price checks
  • Backend jobs
  • Recovery after a WebSocket reconnect

The important point is that you do not need to maintain a live connection just to read the latest available quote.

Option 2: Stream live forex prices with WebSocket

If your screen or system needs continuous price updates, polling the REST API every second is usually not the best approach.

In that case, use a WebSocket stream.

Example:

const ws = new WebSocket(`wss://stream.sifting.io/ws/v1?key=${process.env.SIFTING_KEY}`);

ws.onopen = () => {
  ws.send(JSON.stringify({
    op: "subscribe",
    product: "fx",
    symbols: ["EURUSD", "GBPUSD", "USDJPY"],
  }));
};

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);

  if (update.f === "tick") {
    console.log(update.s, "bid", update.b, "ask", update.a);
  }
};
Enter fullscreen mode Exit fullscreen mode

With WebSocket, you subscribe once and receive updates as prices change.

This is better for:

  • Live tickers
  • Trading screens
  • Monitoring tools
  • Alerts that need fast reaction
  • Applications watching multiple currency pairs at once

REST vs WebSocket for forex prices

Use REST when:

  • You only need the latest quote now
  • You are building a simple converter
  • You refresh a dashboard on a schedule
  • You want a clean request-response workflow

Use WebSocket when:

  • You need prices to update continuously
  • You are watching several pairs at the same time
  • You want to avoid constant polling
  • A delay of even a few seconds matters to the user experience

Both approaches are valid. The right choice depends on how your application uses the data.

Weekend and market-hours behavior

The forex market does not produce new prices all weekend.

A good application should not treat that as a broken feed. It should show a clear market-closed or stale-data state when appropriate.

For example:

  • Keep timestamps in UTC internally
  • Convert to local time only when showing users
  • Handle weekends and market gaps explicitly
  • Show the last available quote clearly when the market is closed

This is especially important for dashboards, converters, and alert systems that users may open outside normal FX market hours.

Common use cases

Real-time forex data is commonly used in:

  • Currency converters
  • Treasury dashboards
  • Trading tools
  • Pricing screens
  • FX alerts
  • Research platforms
  • Internal finance systems
  • Backtesting workflows

The same application may use both REST and WebSocket.

For example, a dashboard might load the latest quote with REST when the page opens, then switch to WebSocket for live updates.

Getting started

SiftingIO provides real-time and historical market data APIs for stocks, FX, crypto, commodities, DEX, and on-chain markets through REST and WebSocket.

For forex prices, the workflow is simple:

  1. Create an API key
  2. Request the latest quote with REST
  3. Use WebSocket when you need continuous updates
  4. Keep your integration consistent across supported asset classes

Useful links:

Top comments (1)

Collapse
 
harjjotsinghh profile image
Harjot Singh •

i like how you broke down the use cases for real-time forex data. having a clear understanding of when to use REST vs WebSocket can really optimize app performance. if you're building something around this, consider using moonshift. it lets you get a full next.js + postgres + auth setup live in about seven minutes, and you keep the code on your github. let me know if you want to try a free build.