Bring AloPrice's live currency, gold and crypto rates into your own stack

Open AloPrice and the screen is a wall of moving numbers: the free-market dollar quoted in rial, a gram of 18-karat gold, a full Bahar Azadi coin, Tether against the toman — each one ticking on its own clock. Per its Google Play listing the app's pitch is plain, "track live currency rates quickly with a simple and easy-to-use design," and that simplicity on the surface hides the thing an integrator actually cares about: a continuously refreshing quote feed covering Iran's open market across four asset classes at once.

So the integration question here is not "can we read a record" but "how do we keep a fast feed in sync without re-pulling the whole board every second." That is an ingestion problem, and it shapes everything below — we read the feed on a cursor, take only what moved, and reconcile against public sources when a segment goes quiet.

The bottom line: AloPrice is a clean ingestion target because almost all of its value is a read-side feed, not a thicket of per-user state. We map the quote endpoints, reproduce the session handshake the app uses, and hand you a client that polls with a cursor. Where the app also keeps things for a signed-in user — a watchlist, a set of price alerts — those come through the account holder's consent, separately and only if you need them.

Price surfaces behind the screens

The rows below mirror what AloPrice presents and what a comparable Iranian aggregator (AlanChand) breaks the same market into. Symbol coverage shifts as the app's catalog changes; we confirm the exact set during the build.

Routes to the rate feed

Three approaches fit this app; in practice the first carries the work and the third backs it up.

Authorized protocol analysis of the in-app feed

We observe the client-to-server traffic under your authorization, map the quote endpoints and their parameters, and reproduce the session token the app sends. This reaches the whole rate board — FX, gold, coin, crypto — at the cadence the app itself sees. Effort is moderate; durability is tied to the app's versions, so we wire a small re-validation check into handover. Access is arranged with you at onboarding, either through a consenting account on a test device or under the app operator's authorization.

User-consented access to per-user surfaces

For the things that belong to one signed-in person — a saved watchlist, alert thresholds, anything the app's "asset management" framing implies — we run under that account holder's consent rather than touching the shared feed. Narrow scope, low volume, used only when your product needs a specific user's view rather than the market.

Public-source cross-feed for redundancy

Because the underlying open-market numbers are also published by neutral aggregators, we can run a second reader against a public source and reconcile. It is not a replacement for AloPrice's own curated set, but it is a cheap safety net: when the primary reader stalls, the cross-feed keeps a sane last-known value flowing and flags the divergence. We would recommend pairing route one as the working spine with this reconciliation layer underneath it.

One refresh cycle, in code

Here is the shape of a single delta poll — illustrative field names, with the real contract confirmed during the build. The client sends back the cursor it got last time; the server returns only rows that moved since.

# Illustrative — endpoint shape confirmed during the build, not a published contract
GET /quotes?since=1718366400&segments=fx,gold,coin,crypto
Authorization: Bearer <app-session-token>

200 OK
{
  "server_time": 1718366460,
  "cursor": 1718366460,            # echo this as ?since= on the next poll
  "quotes": [
    {"symbol":"USD_IRR","seg":"fx",    "buy":..., "sell":..., "unit":"rial", "ts":1718366455},
    {"symbol":"SEKKEH", "seg":"coin",  "bid":..., "ask":...,  "unit":"rial", "ts":1718366451},
    {"symbol":"USDT",   "seg":"crypto","price_irr":..., "price_usd":1.0, "chg24h":-0.4, "ts":1718366459}
  ]
}

# Reader loop (Python sketch)
cursor = load_cursor() or 0
while True:
    r = session.get(QUOTES, params={"since": cursor, "segments": SEGMENTS})
    if r.status_code == 401:          # session lapsed -> redo the handshake, then retry
        session = handshake(); continue
    body = r.json()
    if body["quotes"]:                # empty list == nothing moved this tick
        upsert(normalize(body["quotes"]))   # canonical unit + source tag applied here
    cursor = body["cursor"]; save_cursor(cursor)
    sleep(interval_for(SEGMENTS))     # tighter on fx, looser on coins
      

Two details that matter on this feed specifically: the unit field is non-negotiable because rial and toman both appear, and normalize() is where the source tag (open-market vs official) gets stamped so nothing downstream can blur the two.

What lands in your repo

The deliverable is working code first, with the paperwork that supports it second.

• A runnable feed client in Python and Node.js: the cursor poller above, with persistent cursor, delta merge, backoff, and the session handshake reproduced.
• A normalization layer mapping AloPrice's symbols and units to one stable schema — segment, symbol, buy/sell or bid/ask, canonical unit, source tag, timestamp — so your storage never sees raw inconsistency.
• An automated test suite: recorded response fixtures, a replay runner, and schema assertions so a change in the feed's shape is caught by a check against a known-good snapshot.
• An optional push bridge: when a watched symbol crosses a threshold, emit a signed event to your endpoint instead of making you poll for it.
• An OpenAPI/Swagger description of the mapped feed, a protocol & auth-flow report covering the token handshake and refresh, interface documentation, and short data-retention guidance for what you keep and for how long.

Market rules and the consent basis

The relevant regulator is the Central Bank of the Islamic Republic of Iran (Bank Markazi). It governs the official channels; the numbers AloPrice surfaces are open-market quotes that sit alongside, and often well away from, the official rate — which is exactly why we tag every series by source. There is no open-banking or account-aggregation regime in Iran that applies to a price tracker, so this is not an AIS or consent-mandate situation in the European or Brazilian sense.

The crypto segment carries its own regulatory weather. Per the public record, the central bank blocked crypto-to-rial gateways on 27 December 2024 and began re-permitting exchanges under a state framework in January 2025; reporting points to further tightening through late 2025. We treat that as an availability variable, not a feature, and design around it. Because Iran has no enacted, GDPR-equivalent data-protection statute in force, the dependable basis for the per-user surfaces is the account holder's own consent: we work under NDA, log what we access, keep field collection to what the integration needs, and hold nothing we were not asked to read.

Edges we engineer around

These are the specific things this app makes us account for — handled on our side, not handed to you as homework.

• Rial versus toman. Iranian interfaces switch between the two, and they differ by ten. We pin the unit per field at mapping time and persist a single canonical unit, so an off-by-ten can't ride into your numbers.
• Open-market versus official rate. Two USD prices exist in Iran and they are not interchangeable. Each series we emit carries a source tag so a consumer can't average a street rate with a central rate.
• Geo-restriction and intermittency. Iranian endpoints can be regionally blocked or briefly unreachable. The poller backs off and leans on the public cross-feed so a gap reads as "stale, flagged" rather than a price that fell to zero.
• Crypto isolation. Given the gateway controls above, we keep the crypto reader on its own path; if it drops offline, FX, gold and coin ingestion keep running untouched.

Keeping the numbers honest

On a feed this fast, the dangerous failure is not an error — it's a number that stopped updating but still looks alive. We watch each symbol's timestamp: if one segment's quotes freeze while the rest of the board keeps moving, the reader marks those symbols stale and stops serving them as current, rather than passing a dead price through as fresh. Poll intervals are set per segment — tight on the dollar, looser on a quarter coin that barely moves intraday — so you spend reads where the market actually changes.

Screens we worked from

The app's own listing screenshots — the surfaces the mapping is built against. Select to enlarge.

Other Iranian rate sources

Apps and platforms in the same market — useful when you want one normalized feed that spans several of them. Listed for context, not ranked.

• AlanChand — aggregates currency, gold, Iranian coins and crypto in rial with buy/sell and USD crosses; the closest direct analogue to AloPrice's coverage.
• Bonbast — long-running open-market IRR and toman exchange-rate publisher, widely used as a free-market reference.
• TGJU — broad market-data platform spanning currency, commodity, coin, stock and index quotes.
• Navasan — live currency and gold rate broadcasting with a real-time timeline of moves.
• Nobitex — Iranian cryptocurrency exchange; holds per-user balances and orders rather than just quotes.
• Goldo (Gold Price Live) — focused gold and precious-metals price feed across local currencies.
• CoinGecko — global crypto price and market-cap data, handy for reconciling the crypto segment.
• Investing.com — multi-asset quotes including XAU priced in IRR, useful as a cross-check on gold.

Questions integrators ask

How fast does the feed move, and do you poll it or push from it?

AloPrice refreshes its quotes through the trading day. We read it with a last-updated cursor and pull back only the symbols that actually changed since the previous read, then tune the poll interval per segment because the dollar moves on a different clock than a gold coin. If you want events instead of a feed to scrape, we add a small bridge that pushes a watched symbol to your endpoint when it crosses a threshold you set.

Do the numbers come back in rial or in toman?

Iranian price apps slip between rial and toman, and the two differ by a factor of ten. We pin the unit on every field during mapping and store one canonical unit, so a USD quote never arrives ten times too large or too small in your data.

Can you keep the free-market rate separate from the official rate?

Yes. What AloPrice shows are open-market quotes, not the official central-bank rate, and the two diverge sharply. Every series we emit is tagged by source so a downstream consumer cannot quietly mix a street rate into a calculation that expected the official one.

Given Iran's restrictions on crypto, how reliable is that part of the feed?

The crypto segment is the most exposed to availability swings — Iran's central bank blocked crypto-to-rial gateways in December 2024 and re-permitted them under a state framework in January 2025. We isolate the crypto reader so an outage there does not stall currency and gold ingestion, and reconcile it against public sources when it returns.

What this draws on

Checked in June 2026 against the app's own Google Play listing, a comparable Iranian aggregator for how the market splits into asset classes, and the public record on Iran's central-bank crypto controls. Specifics that would change with an app version — exact symbol set, endpoint shapes — are confirmed during the build rather than assumed here.

• AloPrice on Google Play — listing, category and description.
• AlanChand — comparable Iranian currency/gold/coin/crypto aggregator, used to model the asset breakdown.
• Cryptocurrency in Iran — central-bank gateway controls, Dec 2024 / Jan 2025.
• TGJU — Iranian market-data platform, reference for the wider rate ecosystem.

Compiled by OpenFinance Lab — engineering notes, June 2026.

A first AloPrice feed client — normalized, unit-pinned, source-tagged and tested — lands inside one to two weeks. Take it as source you own and keep, from $300, invoiced only after delivery once it runs to your satisfaction; or call our hosted endpoints instead and pay per call with nothing upfront. Tell us which symbols and segments you need and we'll scope it — Start with OpenFinance Lab