What Israel Exchange Rates - ILS reads, and how to read it directly

Twenty-eight currencies, six banks, one shekel benchmark — that is the dataset this app puts on a phone screen, and every number in it originates server-side, not on the device. The official figures come from the Bank of Israel; the comparison columns come from the banks themselves. The app aggregates and displays. None of that data is locked to a personal account, which changes the integration problem in a useful way: there is nothing to log into, so the question is simply which upstream source each number comes from and how to read it cleanly.

The bottom line for an integrator: the Bank of Israel publishes its representative rates as an open-data series, queryable through a documented SDMX endpoint, and that is the part worth building on first. The per-bank spreads — what Hapoalim or Leumi actually quote — live on each bank's own published board and need a separate extraction step. We would build the official feed as the stable core and layer the bank comparison on top of it, because that split matches how the two kinds of number behave.

Where the numbers come from

Each row below is a real surface of this app, mapped to where the value actually originates and what an integrator would do with it.

Reaching the rates directly

Three routes genuinely apply to this app. They differ in what they reach and how long they stay stable.

Bank of Israel open-data SDMX feed

The Bank of Israel runs a series server (a Fusion edge server) that exposes its statistics — including representative exchange rates — over an SDMX 2.1 data API, with output in sdmx-json, CSV, or XML. This reaches the official rate and its full history, supports date ranges and a last-N-observations parameter, and is the most durable surface available, because it is a published reuse channel rather than a scraped page. We set up the series-key mapping for all 28 currencies and wire the pulls. This is the route we lean on for the benchmark.

Authorized per-bank extraction

The six-bank comparison is the app's distinctive feature, and those numbers are not in the central feed. Each bank publishes its own FX board; reading them is documented protocol analysis of public pages, performed under your authorization. It reaches the buy/sell and cash/transfer spreads the app compares. It is less durable than the SDMX feed — a bank redesigning its board can change the shape — so we build it with a re-validation step that flags layout drift rather than silently returning stale figures.

App-traffic protocol analysis

If you want the exact merged dataset the way this app assembles it — the same currency set, the same bank list, the same alignment — we can analyze the app's own traffic to mirror its aggregation logic precisely. This is the most faithful reproduction of the app's view and the right choice when the goal is a drop-in equivalent rather than your own blend of sources.

For most clients the practical answer combines the first two: the SDMX feed for the authoritative shekel rate and its history, the per-bank layer for the comparison the app is known for. The third route is what we reach for when the requirement is to replicate this specific app's merged output exactly.

The build you get

Deliverables are tied to the surfaces above, not a generic list.

• OpenAPI specification for a normalized rate service — one schema covering the BOI benchmark and the per-bank boards, so a caller sees a single consistent shape.
• Runnable source (Python or Node.js) for the SDMX pulls, the per-bank extraction adapters, and the merge that produces one record per currency.
• Protocol report documenting the SDMX dataflow keys, query parameters, and each bank board's structure as confirmed during the build.
• Automated tests that assert the 28-currency set is complete, that observation timestamps are present, and that a bank-board layout change trips an alarm instead of passing bad data through.
• Interface documentation plus guidance on attribution, retention, and the daily-vs-intraday cadence of each source.

A sample BOI pull

Illustrative — the endpoint, dataflow id and parameters were confirmed against the Bank of Israel extraction guide during the build; the delivered client maps series keys for every currency rather than one hard-coded pair.

import requests

# Bank of Israel "edge" series server: SDMX 2.1, sdmx-json output.
# Representative USD/ILS, last 5 daily observations.
BASE = "https://edge.boi.gov.il/FusionEdgeServer/sdmx/v2/data/dataflow"
url  = f"{BASE}/BOI.STATISTICS/EXR/1.0/RER_USD_ILS"

resp = requests.get(url, params={
    "format": "sdmx-json",
    "lastNObservations": 5,
}, timeout=20)
resp.raise_for_status()

doc    = resp.json()
ds     = doc["data"]["dataSets"][0]
dims   = doc["data"]["structure"]["dimensions"]["observation"][0]["values"]
series = next(iter(ds["series"].values()))

# normalize to [{date, rate}] — the adapter repeats this for all 28 pairs
rows = [
    {"date": dims[int(i)]["id"], "rate": obs[0]}
    for i, obs in series["observations"].items()
]
# on a non-business day the series simply has no new observation;
# the merge layer carries the last representative rate forward and
# marks it stale rather than inventing a value.

Freshness and when rates move

The two source types do not refresh on the same clock, and a correct client treats them differently. The Bank of Israel sets a representative rate once per foreign-currency business day — so weekends, and Israeli holidays, produce no new observation rather than a zero. The commercial banks move their own boards through the trading day. We poll each source on its own cadence, attach the observation time to every value, and never blend a stale benchmark with a fresh bank quote without flagging the gap. That timestamp discipline is what lets a downstream system trust which number is current.

Public data, used the public way

This integration touches no personal data — there is no account, no balance, no identity in the dataset, only market rates. The representative figures are published by the Bank of Israel as open data through its series server for reuse, and we carry that source attribution through into the delivered client. Bank-board figures are public information on each bank's own site; any reuse terms specific to a bank are read per source during the build. Israel's broader open-banking work — the Banking Supervision Department's Proper Conduct of Banking Business directive on account access — governs consented access to customer accounts and does not bear on public rate data, so it is not the regime here. We operate authorized and logged, record what was fetched and when, minimize to the rate fields needed, and work under NDA where a client requires it.

Things we account for

Two points shape how we build this one, and we handle both rather than hand them to you.

• Non-business-day gaps. The shekel benchmark is unset on Fridays, Saturdays and Israeli holidays. We design the merge so a missing observation carries the last representative rate forward and marks it stale — never a silent zero, never a fabricated mid-week value.
• Per-bank board drift. Six banks each publish in their own layout, and any one can redesign without notice. We isolate each bank behind its own adapter and add a re-validation pass that compares the parsed shape against an expected signature, so a front-end change surfaces as a flagged failure during maintenance instead of as wrong rates in production.
• Currency-set completeness. The app advertises 28 currencies; a partial pull is a real risk with SDMX key mapping. Tests assert the full set rather than trusting that a request silently returned everything.

Where this gets used

• An accounting or invoicing system that needs the official ILS benchmark stamped to each transaction date, pulled straight from the BOI series.
• A remittance or treasury tool that wants the six-bank comparison to route a transfer through the cheapest spread.
• A research dashboard charting shekel trends over 1m–1y windows from the same history the app's charts draw on.

Interface evidence

The app's own screens, for reference to the surfaces described above.

What I checked

I read the app's Play listing for its currency set and bank list, then confirmed the Bank of Israel rate-extraction route against the bank's own documentation and series server, and reviewed the state of Israel's open-banking regulation to confirm it does not apply to public rate data. Primary sources, opened during this mapping:

• Bank of Israel — Exchange Rates
• BOI — extracting representative exchange rates from the series database (example)
• BOI Fusion Data Browser / series edge server
• BOI — Banking Supervision Department on the open-banking standard

Mapped by the OpenBanking Studio integration desk, 5 June 2026.

Other apps over the same rates

Same category, useful for seeing how one normalized rate service spans several sources.

• XE Currency Converter — live rates for 180-plus currencies from its own aggregated feed, plus money-transfer accounts.
• Wise — mid-market rates alongside per-user multi-currency balances held behind login.
• Revolut — a multi-currency wallet with per-user balances and in-app FX execution.
• OANDA Currency Converter — live and historical FX offered as a licensed data product.
• X-Rates — web-based shekel and cross-rate tables built on a shared rate feed.
• Easy Currency Converter — an offline-capable converter caching a periodically refreshed feed.
• Bank Hapoalim and Bank Leumi apps — per-user banking plus each bank's own published FX board, one of the comparison sources here.

Questions integrators ask

Can you give me the same six-bank comparison the app shows, not just the central rate?

Yes. The Bank of Israel representative rate is one series; the side-by-side figures for Hapoalim, Leumi, Mizrahi Tefahot, First International, Discount and Israel Post each come from that bank's own published FX surface. We read all of them, align the buy/sell and cash/transfer columns, and hand back a single merged record per currency so your output mirrors what the app puts on screen.

Is the Bank of Israel SDMX feed enough on its own, or do you also read the banks?

The SDMX feed at edge.boi.gov.il carries the official representative rates and their history, and it is the durable part. It does not carry each commercial bank's own spread. If you only need the benchmark, the feed alone is fine; if you need the comparison the app is built around, we add a per-bank extraction layer on top.

How current are the rates you would serve — daily or intraday?

The Bank of Israel representative rate is set once per foreign-currency business day, so that series is daily. The individual banks refresh their own boards through the day, so the comparison layer can be polled intraday. We set the poll cadence per source and stamp every value with its observation time.

The app says it is not affiliated with the Bank of Israel — does reusing these rates raise a licensing question?

The representative rates are published by the Bank of Israel as open data through its series server, intended for reuse with attribution. We carry the source attribution through to the delivered client, keep the data non-personal, and log what was fetched and when. Any bank-specific reuse terms are reviewed per source during the build.

A working ILS-rate client — the SDMX pulls, the six-bank merge, normalized JSON, tests, and documentation — comes together in one to two weeks. Source-code delivery starts at $300 and is billed only after we hand it over and you are satisfied with it; alternatively, skip owning the code and call our hosted endpoints, paying per call with nothing upfront. Tell us the app and what you need from its rates at our contact page and we will scope it. Access to any source that needs arranging is handled with you as part of the work, not asked of you first.