Pulling live quotes and screeners out of US Stock

A US-stock price that is fifteen minutes stale is exactly what CMoney built this app to remove. US Stock (美股K線) streams live prices for individual stocks and ETFs, then stacks several stock-selection engines and a discussion feed on top of that data. For an integrator, the valuable part is not the chrome — it is the live quote endpoint and the screener result sets sitting behind the login. This brief maps what the app holds and the authorized way to reach it.

The app's published differentiator is real-time quotes where most Taiwan-facing tools sit on a 15-minute delay. That single fact drives the integration: the live feed and the screeners are the surfaces worth wiring, and both ride the same authenticated traffic. The watchlist and the saved stock-selection lists are per-user state, reached with the account holder's consent.

What US Stock keeps on its servers

These are the surfaces named the way the app names them, mapped to what an integrator would actually do with each.

Authorized ways into the data

Interface integration and protocol analysis

We capture the app's own authenticated HTTPS calls — under your authorization, against a consenting account set up during onboarding — and document the live quote endpoint, the screener calls and the news feed. Reachable: quotes, screens, fundamentals, news. Effort is moderate; durability is good with a monitor on the response shape. This is where the live feed actually lives.

User-consented account access

With the account holder's login, the per-user state — watchlist and any saved selection lists — is pulled directly and the consent is recorded. Effort is low to moderate. This is the clean route to anything tied to a specific person rather than the market.

Native capture as a backstop

Where a list is only rendered in the app and never returns cleanly over the wire, we read it from the rendered view. It is the least durable path and we keep it for the rare list, not for the bulk of the work.

On this app the live quote endpoint and the screener calls are the same authenticated traffic, so the build sits on interface integration, and we add the consenting account to reach a named user's watchlist. Native capture stays in reserve for any list that never hits the network in a usable form.

What ends up in your repo

• An OpenAPI/Swagger specification covering the quote, watchlist, screener, fundamentals and news endpoints, with request and response shapes.
• A protocol and auth-flow report: the device-login to bearer-token to refresh chain, the headers that matter, and the observed rate limits.
• Runnable source in Python and Node.js for the two endpoints integrators ask for first — the live quote pull and a screener list pull.
• Automated tests, including a token-refresh case and an assertion that the app's freshness flag is preserved rather than dropped.
• Interface documentation plus a normalized schema that maps the app's raw field names to clean, stable ones.
• Data-retention and consent guidance written against Taiwan's PDPA, so the per-user pulls are defensible.

A quote and watchlist pull, sketched

Illustrative only. The host, header set and field names are confirmed during the build against a consenting account, not asserted from any published spec.

# US Stock — live quote pull with token refresh
import requests

BASE = "https://<host-resolved-during-capture>/v1"

def login(account, secret):
    r = requests.post(f"{BASE}/identity/token",
                      json={"account": account, "secret": secret}, timeout=10)
    r.raise_for_status()
    t = r.json()
    return t["access_token"], t["refresh_token"], t["expires_in"]

def quotes(token, symbols):
    r = requests.get(f"{BASE}/usstock/quote",
                     params={"symbols": ",".join(symbols)},      # e.g. AAPL,NVDA,VOO
                     headers={"Authorization": f"Bearer {token}"}, timeout=10)
    if r.status_code == 401:
        raise TokenExpired          # caller refreshes, then retries once
    r.raise_for_status()
    # keep the app's own freshness flag; never assume a row is live
    return [{"symbol": q["symbol"], "last": q["last"],
             "as_of": q["ts"], "delayed": q["delayed"]}
            for q in r.json()["quotes"]]

def watchlist(token):
    r = requests.get(f"{BASE}/usstock/watchlist",
                     headers={"Authorization": f"Bearer {token}"}, timeout=10)
    r.raise_for_status()
    return [row["symbol"] for row in r.json()["items"]]   # per-user, consented
      

Keeping the live feed honest

The app's whole pitch is zero-delay quotes, so the integration has to defend that, not quietly erode it. Three things we handle in the sync. Each row carries a delayed flag; we propagate it instead of stamping everything as live. US market hours and Taiwan time both appear in the app, so timestamps are normalized to UTC with the session attached, and a pre-open print is never mistaken for a close. And the screener lists recompute overnight — yesterday's hottest stocks become today's different list — so each set is pinned to its as-of date downstream.

Consent and Taiwan's data law

Per-user data — the watchlist, the saved selections, the account profile — falls under Taiwan's Personal Data Protection Act. The PDPA was amended in November 2025, adding GDPR-style breach-notification duties, per the Jones Day summary below; consent is required to collect and use the data, and a revoked consent must stop the processing. The dependable basis for this work is the account holder's own consent, paired with authorized interface integration. Taiwan's FSC open-banking standards — the three-phase FISC scheme, with Phase 2 customer-information inquiry live since 2020 — govern banks, not a market-data and community app like this one, so they are context rather than the hook here. We work authorized and documented, log the consent records, minimize the pull to the symbols and lists actually requested, and sign an NDA where the engagement needs one.

What we plan around on this build

• The live feed is the app's edge, so we design the sync to respect the upstream entitlement and the observed rate limits — pacing the quote polls so we do not trip throttling and lose the very freshness we are there to keep.
• Selection lists are recomputed daily and the labels stay the same while the contents change. We pin every result set to its computed date, so a "technical rankings" signal pulled on Tuesday is not silently overwritten by Wednesday's run.
• App releases move fast — version 1.52.1 was the current build in early 2026 per APKFab — so we keep a monitor on the response shape that flags a renamed or relocated field before it reaches your data, and that upkeep is folded into the engagement.

The screens we mapped against

The app's own screenshots show the quote, selection and discussion surfaces this brief refers to. Select one to enlarge.

What we checked, and when

This mapping draws on the app's Google Play and App Store listings (category, rating near 4.8, 100K+ installs and the feature set, all as the stores describe them), the APKFab record for the current build, the FSC's open-banking bulletin for the scope of Taiwan's scheme, and Taiwan's PDPA statute plus a 2025 amendment summary. Reviewed on 11 June 2026 against the live listings.

• Google Play — US Stock (com.cmoney.usstock)
• App Store — US Stock (id6472171216)
• FSC — Phase 2 Open Banking bulletin
• Taiwan Personal Data Protection Act (statute)
• Jones Day — 2025 PDPA amendments

Compiled by the OpenBanking Studio integration desk · 11 June 2026.

The Taiwan US-stock app cluster

Apps a single integration is often asked to sit alongside, with a neutral note on the data each holds:

• 美股夢想家 (US Stock Dreamer) — a CMoney app pairing an analyst's US-stock commentary and picks with member discussion.
• 美股同學會 (US Stock Forum) — a CMoney community where members track and debate popular US tickers.
• 投資癮 (Wealtholic) — a CMoney app that organizes personal investment records and watchlists.
• 存股價值K線 (Value K) — a CMoney candlestick app focused on dividend and value plays.
• 股市籌碼K線 (Chip K) — a CMoney app surfacing institutional order-flow ("chip") data on equities.
• moomoo — a broker app offering free real-time US quotes and Level-2 depth to account holders.
• Webull — a trading app with US real-time quotes, charts and a watchlist behind a brokerage account.
• TradingView — a charting platform holding user watchlists, alerts and live-quote subscriptions.

Questions integrators ask about US Stock

Does the integration keep US Stock's quotes live, or do we inherit the 15-minute delay the app sells against?

We sync against the same authenticated live feed the app uses for stocks and ETFs, carry the app's own freshness flag through to your records, and normalize the Taiwan and US-market timestamps so a pre-open price is never read as a close. The point of the app is zero-delay quotes, and the integration is built to preserve that.

Can you capture the Master Stock Picks and the fundamental screens, not just prices?

Yes. The institutional allocation lists, the ROE, growth, profitability and continuous-dividend screens, the recommended-stock set and the daily technical rankings are each pulled as dated result sets, so a signal does not silently change when the app recomputes its lists overnight.

US Stock is a Taiwanese app, so which data rules govern this and do Taiwan's open-banking standards apply?

Per-user data such as your watchlist and account profile sits under Taiwan's Personal Data Protection Act, amended in November 2025 toward GDPR-style breach duties. The FSC open-banking standards apply to banks rather than a market-data and community app like this one, so the dependable basis we work from is the user's own consent together with authorized interface integration.

If a future app update renames a quote field, who keeps the feed from breaking?

We do. A monitor watches the response shape, so a renamed or moved field is caught before bad data reaches you, and that upkeep is part of the engagement rather than a separate ask. A first working build lands within one to two weeks.

Starting the build

You give us the app name and what you want out of its data; access to a consenting account, any sandbox, and the compliance paperwork are arranged with you as part of the work, not asked of you up front. A first working build runs in one to two weeks. Source-code delivery starts at $300 — runnable code plus the spec, tests and interface docs, paid only after delivery once you are satisfied; or call our hosted endpoints and pay per call with nothing up front. Tell us which surfaces of US Stock you need and we will scope it: start a conversation.