Real-Time Forex Data API by Infoway

Infoway API aggregates Forex price data from major market makers and delivers it through a unified REST and WebSocket interface. For forex, this means genuine real-time rates with latency consistently under 100ms and an SLA of 99.6% uptime.

The forex feed covers 42 currency pairs across all major and several exotic pairs:

Symbol	Pair
EURUSD	Euro / US Dollar
GBPUSD	British Pound / US Dollar
USDJPY	US Dollar / Japanese Yen
USDCHF	US Dollar / Swiss Franc
AUDUSD	Australian Dollar / US Dollar
NZDUSD	New Zealand Dollar / US Dollar
USDCAD	US Dollar / Canadian Dollar
USDCNY	US Dollar / Chinese Yuan
USDCNH	US Dollar / Offshore Chinese Yuan
USDHKD	US Dollar / Hong Kong Dollar
USDSGD	US Dollar / Singapore Dollar
USDTHB	US Dollar / Thai Baht
USDTWD	US Dollar / Taiwan Dollar
USDRUB	US Dollar / Russian Ruble
EURJPY	Euro / Japanese Yen
EURGBP	Euro / British Pound
EURCHF	Euro / Swiss Franc
EURAUD	Euro / Australian Dollar
EURCAD	Euro / Canadian Dollar
EURNZD	Euro / New Zealand Dollar
GBPJPY	British Pound / Japanese Yen
GBPCHF	British Pound / Swiss Franc
GBPAUD	British Pound / Australian Dollar
GBPCAD	British Pound / Canadian Dollar
GBPNZD	British Pound / New Zealand Dollar
AUDJPY	Australian Dollar / Japanese Yen
AUDCHF	Australian Dollar / Swiss Franc
AUDCAD	Australian Dollar / Canadian Dollar
AUDNZD	Australian Dollar / New Zealand Dollar
AUDDKK	Australian Dollar / Danish Krone
CADJPY	Canadian Dollar / Japanese Yen
CADCHF	Canadian Dollar / Swiss Franc
CADUSD	Canadian Dollar / US Dollar
CHFJPY	Swiss Franc / Japanese Yen
CHFUSD	Swiss Franc / US Dollar
NZDJPY	New Zealand Dollar / Japanese Yen
NZDCAD	New Zealand Dollar / Canadian Dollar
SGDUSD	Singapore Dollar / US Dollar
CNYUSD	Chinese Yuan / US Dollar
JPYUSD	Japanese Yen / US Dollar
USDEUR	US Dollar / Euro
USDGBP	US Dollar / British Pound

Beyond forex, the same API key gives you access to equities (US, HK, China A-shares, Japan, India), crypto, commodities, precious metals, and CFDs — all through the same interface. If your application eventually grows to cover more than just currencies, you won't need to stitch together multiple providers.

Getting Started

Sign up at the Infoway website to get your API key. New accounts automatically receive a 7-day trial — no credit card required. Your key shows up in the dashboard immediately, and you can start making requests within minutes.

Every request needs the API key passed as a request header:

apiKey: YOUR_API_KEY_HERE

REST API Examples

The forex endpoints use the /common/ path prefix. Here's how to pull data for the most common use cases.

Latest Trade Price

The trade endpoint returns the most recent transaction for one or more currency pairs.

import requests

url = "https://data.infoway.io/common/batch_trade/EURUSD,GBPUSD,USDJPY"

headers = {
    "User-Agent": "Mozilla/5.0",
    "Accept": "application/json",
    "apiKey": "YOUR_API_KEY_HERE"
}

response = requests.get(url, headers=headers)
print(response.json())

Response:

{
  "ret": 200,
  "msg": "success",
  "traceId": "a1b2c3d4-1234-5678-abcd-ef0123456789",
  "data": [
    {
      "s": "EURUSD",
      "t": 1781672609412,
      "p": "1.08423",
      "v": "1.0",
      "vw": "1.08423",
      "td": 1
    },
    {
      "s": "GBPUSD",
      "t": 1781672609318,
      "p": "1.27185",
      "v": "1.0",
      "vw": "1.27185",
      "td": 2
    },
    {
      "s": "USDJPY",
      "t": 1781672609501,
      "p": "149.832",
      "v": "1.0",
      "vw": "149.832",
      "td": 0
    }
  ]
}

Field	Description
s	Symbol
t	Timestamp (milliseconds)
p	Trade price
v	Volume
vw	Trade value
td	Direction: 0 = default, 1 = buy, 2 = sell

You can query up to 100 symbols in a single request by comma-separating them in the URL path.

Candlestick / OHLCV Data

The candle endpoint supports 12 timeframes from 1-minute to yearly. It uses a POST request with a JSON body.

import requests
import json

url = "https://data.infoway.io/common/v2/batch_kline"

headers = {
    "User-Agent": "Mozilla/5.0",
    "Accept": "application/json",
    "Content-Type": "application/json",
    "apiKey": "YOUR_API_KEY_HERE"
}

payload = {
    "klineType": 1,      # 1 = 1-min, 2 = 5-min, 5 = 1-hour, 8 = daily
    "klineNum": 20,      # Number of candles to return (max 500 per symbol)
    "codes": "EURUSD,GBPUSD"
}

response = requests.post(url, headers=headers, data=json.dumps(payload))
print(response.json())

Response:

{
  "ret": 200,
  "msg": "success",
  "traceId": "b2c3d4e5-2345-6789-bcde-f01234567890",
  "data": [
    {
      "s": "EURUSD",
      "respList": [
        {
          "t": "1781671920",
          "o": "1.08401",
          "h": "1.08435",
          "l": "1.08398",
          "c": "1.08423",
          "v": "142.0",
          "vw": "154.08",
          "pc": "0.02%",
          "pca": "0.00022"
        }
      ]
    }
  ]
}

Field	Description
t	Candle open time (Unix seconds)
o	Open
h	High
l	Low
c	Close
v	Volume
vw	Trade value
pc	Change %
pca	Change (absolute)

To pull historical candles, add a timestamp field to the request body. The API will return candles going back from that Unix timestamp:

payload = {
    "klineType": 8,           # Daily candles
    "klineNum": 500,
    "codes": "EURUSD",
    "timestamp": 1770000000   # Pull up to 500 daily candles ending at this time
}

Minute-level history goes back 3 years. Daily and above have no lookback restriction.

Order Book (Bid/Ask)

The depth endpoint returns the current best bid and ask for one or more pairs.

import requests

url = "https://data.infoway.io/common/batch_depth/EURUSD,USDJPY"

headers = {
    "User-Agent": "Mozilla/5.0",
    "Accept": "application/json",
    "apiKey": "YOUR_API_KEY_HERE"
}

response = requests.get(url, headers=headers)
print(response.json())

Response:

{
  "ret": 200,
  "msg": "success",
  "traceId": "c3d4e5f6-3456-7890-cdef-012345678901",
  "data": [
    {
      "s": "EURUSD",
      "t": 1781672693007,
      "a": [
        ["1.08431"],
        ["0.0"]
      ],
      "b": [
        ["1.08415"],
        ["0.0"]
      ]
    }
  ]
}

a is the ask (sell side), b is the bid (buy side). Each contains a price array and a volume array, matched by index position.

WebSocket for Real-Time Streaming

REST polling works well for dashboards that refresh every few seconds, but if you're building something that needs to react to price moves in real time — an alert system, an automated strategy, a trading terminal — you want a persistent WebSocket connection instead.

The WebSocket endpoint for forex (and all common-type products like commodities and precious metals) is:

wss://data.infoway.io/ws?business=common&apikey=YOUR_API_KEY_HERE

Once connected, the server pushes updates to you as they happen. No polling, no repeated round trips.

Here's a production-ready Python client that subscribes to live trades, order book updates, and 1-minute candles for a set of forex pairs, with automatic reconnection on disconnect:

import asyncio
import json
import uuid
import logging
from typing import Optional
import websockets
from websockets.exceptions import ConnectionClosed

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s"
)
logger = logging.getLogger("forex-ws")

PAIRS = "EURUSD,GBPUSD,USDJPY,AUDUSD,USDCAD"

class ForexWebSocketClient:
    """Real-time forex streaming client with auto-reconnect."""

    def __init__(self, api_key: str):
        self.url = f"wss://data.infoway.io/ws?business=common&apikey={api_key}"
        self.ws: Optional[websockets.WebSocketClientProtocol] = None
        self.running = True
        self.reconnect_base = 5
        self.reconnect_max = 60
        self.heartbeat_interval = 30
        self._heartbeat_task: Optional[asyncio.Task] = None

    def _trace(self) -> str:
        return str(uuid.uuid4())

    async def _send(self, msg: dict) -> None:
        if self.ws:
            await self.ws.send(json.dumps(msg))

    async def _subscribe(self) -> None:
        # Subscribe to live trades
        await self._send({
            "code": 10000,
            "trace": self._trace(),
            "data": {"codes": PAIRS}
        })
        await asyncio.sleep(5)

        # Subscribe to order book
        await self._send({
            "code": 10003,
            "trace": self._trace(),
            "data": {"codes": PAIRS}
        })
        await asyncio.sleep(5)

        # Subscribe to 1-minute candles
        await self._send({
            "code": 10006,
            "trace": self._trace(),
            "data": {
                "arr": [{"type": 1, "codes": PAIRS}]
            }
        })
        logger.info("Subscribed to %s", PAIRS)

    def _start_heartbeat(self) -> None:
        if self._heartbeat_task and not self._heartbeat_task.done():
            self._heartbeat_task.cancel()

        async def beat():
            while True:
                await asyncio.sleep(self.heartbeat_interval)
                if not self.ws or self.ws.close_code is not None:
                    break
                try:
                    await self._send({"code": 10010, "trace": self._trace()})
                    logger.debug("Heartbeat sent")
                except Exception:
                    break

        self._heartbeat_task = asyncio.create_task(beat())

    def _handle(self, raw: str) -> None:
        try:
            msg = json.loads(raw)
        except json.JSONDecodeError:
            logger.error("Bad message: %s", raw)
            return

        code = msg.get("code")
        data = msg.get("data", {})

        if code == 10002:       # Trade push
            logger.info("Trade  %s @ %s", data.get("s"), data.get("p"))
        elif code == 10005:     # Depth push
            logger.info("Depth  %s bid=%s ask=%s",
                        data.get("s"),
                        data.get("b", [[None]])[0][0],
                        data.get("a", [[None]])[0][0])
        elif code == 10008:     # Candle push
            logger.info("Candle %s o=%s h=%s l=%s c=%s",
                        data.get("s"), data.get("o"),
                        data.get("h"), data.get("l"), data.get("c"))
        elif code == 10010:
            logger.debug("Heartbeat ack")
        elif code in (10001, 10004, 10007):
            logger.info("Subscription confirmed (code=%s)", code)
        else:
            logger.debug("Message: %s", raw)

    async def _connect_once(self) -> None:
        async with websockets.connect(self.url) as ws:
            self.ws = ws
            logger.info("Connected to %s", self.url)
            await self._subscribe()
            self._start_heartbeat()
            try:
                async for message in ws:
                    self._handle(message)
            finally:
                if self._heartbeat_task:
                    self._heartbeat_task.cancel()
                self.ws = None

    async def start(self) -> None:
        backoff = self.reconnect_base
        while self.running:
            try:
                await self._connect_once()
                backoff = self.reconnect_base
            except ConnectionClosed as e:
                logger.warning("Connection closed: %s", e)
                backoff = self.reconnect_base
            except Exception as e:
                logger.error("Connection error: %s", e)

            if not self.running:
                break
            logger.info("Reconnecting in %ss...", backoff)
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, self.reconnect_max)

    def stop(self) -> None:
        self.running = False


async def main():
    client = ForexWebSocketClient(api_key="YOUR_API_KEY_HERE")
    await client.start()


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("Stopped")

WebSocket Protocol Reference

Code	Direction	Description
10000	Client → Server	Subscribe to trades
10001	Server → Client	Trade subscription confirmed
10002	Server → Client	Trade data push
10003	Client → Server	Subscribe to order book
10004	Server → Client	Order book subscription confirmed
10005	Server → Client	Order book push
10006	Client → Server	Subscribe to candles
10007	Server → Client	Candle subscription confirmed
10008	Server → Client	Candle push
10010	Both	Heartbeat

One connection supports subscribing to up to 600 symbols simultaneously. The server will drop the connection if no heartbeat is received within 60 seconds, so make sure your client sends one every 30 seconds.

Frequently Asked Questions

When is the forex market open?

The forex market trades 24 hours a day, five days a week. It opens Sunday evening (New York time) with the Sydney session, and the major liquidity windows are the London session (roughly 3am–12pm ET) and the New York session (8am–5pm ET). The overlap between London and New York (8am–12pm ET) is typically when spreads are tightest and volume is highest.

How do I query multiple currency pairs at once?

Comma-separate the symbols in the REST endpoint path or in the codes field of your WebSocket subscription message. REST supports up to 100 symbols per request. WebSocket supports up to 600 per connection.

What is the latency on the price feed?

Under normal market conditions, the measured latency between a market event and data availability via WebSocket is under 100ms. REST requests add a round-trip on top of that, so WebSocket is the right choice for latency-sensitive applications.

Does Infoway API provide historical forex data?

Yes. You can pull minute-level historical data going back 3 years by passing a timestamp parameter in the candle request body. Daily and weekly candles have no lookback limit.

What's the difference between USDCNY and USDCNH?

CNY is the onshore Chinese yuan (traded on the mainland, subject to PBOC controls). CNH is the offshore yuan traded in Hong Kong and other international markets — it moves more freely based on global supply and demand. The two rates often diverge slightly, and that spread itself can be a useful signal.

Is there a free trial?

Yes — register on the Infoway website and you'll get a 7-day trial automatically. No credit card, no identity verification required. The trial lets you query all markets and data types, with a rate limit of 60 REST requests per minute and up to 10 WebSocket subscriptions. Feel free to reach out to our support team on Telegram if you have any questions during the trial.