What it takes to mirror HWS Chart Viewer's markup feed

Every markup in HWS Chart Viewer arrives from a server. The app draws sharp, zoomable annotated charts that Hidden Wealth Society publishes, and tags each one by market, pairing, and order type. Nothing in the app is generated on the phone. That single fact decides the integration: the value is a remote, membership-gated content feed, and the work is keeping an external copy of that feed honest and in step.

The viewer is built for review, not for export. Swipe through the latest markups, load previous days, jump between categories. A trader using the data downstream — in a dashboard, an alerting bot, or a research archive — needs the same items as structured records, with their category and status attached. That is the brief below.

Bottom line: the markups only exist behind a Hidden Wealth Society login, so the dependable way in is a session driven by the customer's own membership credentials. That reaches everything a paying member sees and stays stable as long as the membership is active. Reading the app's own requests then recovers the category and status tags cleanly, which is the part a plain screen-scrape tends to lose.

What the app actually holds

These are the surfaces a member touches, named the way the app names them, with what each is good for once it is a record rather than a screen.

Getting at the feed

Consented-membership session

The customer's own Hidden Wealth Society login drives a headless session. It reaches precisely what that member is entitled to, which is the whole point: no shared credentials, no access beyond the subscription on file. Effort is moderate and durability is high — it keeps working for as long as the membership does. We set the session up with the customer during onboarding, against their account.

Protocol analysis of the app's traffic

Watching how the app requests and renders markups, under the customer's authorization, recovers the structured fields — category, pairing, order type, status, publish time — that a visual capture flattens. We use it to pin down the exact request shape and pagination so the feed mirror matches the in-app order.

Image capture as a backstop

Where a markup can be saved or shared as an image, that image is a reliable fallback artifact even if the metadata around it shifts. We keep it as the source-of-truth picture and attach extracted fields next to it.

For this app the session route carries the work, because the data simply does not exist outside a logged-in membership; protocol analysis is what makes the mirror structured rather than a pile of screenshots, and the image backstop is there so a front-end change never costs you the underlying chart. That ordering is specific to a feed that is gated, image-first, and tagged.

A worked request

Illustrative, and confirmed in shape during a build — field names are normalized on our side, not lifted verbatim. A markup-list pull against an authenticated session, paging back the way "load previous days" does:

GET /api/markups?category=forex&pair=EURUSD&before=2026-05-30T00:00:00Z&limit=50
Cookie: hws_session=<member-session-token>
Accept: application/json

200 OK
{
  "markups": [
    {
      "id": "mk_8f21c",
      "published_at": "2026-05-30T13:42:11Z",
      "market": "forex",
      "pair": "EUR/USD",
      "order_type": "limit",
      "status": "active",
      "image_url": "https://cdn.example/markups/mk_8f21c.png",
      "title": "EURUSD 4H continuation"
    }
  ],
  "next_before": "2026-05-29T22:10:00Z"
}

# Pagination walks next_before backward until it returns null.
# 401 -> session expired: re-run the consented login flow, then retry.
# 429 -> back off on the poll cadence; markups are not high-frequency.

The error handling matters more than the happy path here. A trading feed that silently drops to an expired session looks identical to a quiet market, so the client treats a 401 as a re-auth event rather than an empty result.

What lands in your repo

Concrete artifacts, each tied to a surface above:

• An OpenAPI specification for the normalized markup endpoints — list, by-category, single markup, and the backfill walk.
• A protocol and auth-flow report covering the membership login, the session token or cookie chain, and where category and status live in the responses.
• Runnable source in Python and Node.js that pulls the latest feed, backfills the previous-day archive, and emits records keyed by markup id.
• Automated tests, including the 401 re-auth path and dedupe-on-resync.
• Interface documentation, plus retention and access guidance for holding someone else's published charts.

Build notes worth stating up front

Things we account for on this specific app, so they do not surprise anyone mid-build:

• We design the poller around how the app loads "previous days", so backfill pages do not miss markups posted between two syncs — the cursor walks the same boundary the app does.
• We map the category facets (market type, pairing, order type, chart status) to a stable schema, so a re-tag on Hidden Wealth Society's side does not break your downstream filters.
• Because each markup is fundamentally an image, we keep the annotated chart as the source artifact and carry extracted metadata alongside it, and we wire a check that flags when the app's front end changes shape.
• We scope the sync to the consenting account's tier — the free Hidden Hub and a paid membership see different things — so the integration only reaches what that account is entitled to. Access is arranged with you during onboarding, against your own login or a consenting member's.

Consent and the data rules that apply

This is not a bank, a wallet, or a payment rail, so no account-information or open-banking scheme governs it. The personal data in play is narrow: the member's own account and session. The dependable basis for the whole integration is that member's authorization to reach the subscription they already pay for — reported around $49.99 per month for the paid tier, per third-party reviews of the Hidden Society membership, with a free Hidden Hub tier alongside it.

Where members sit in the EU or California, GDPR or CCPA frame how their account data is handled; we minimize to what the integration needs, log access, keep consent records, and sign an NDA when the customer wants one. The markups themselves stay Hidden Wealth Society's intellectual property. We move them into the customer's own stack for the customer's own use, under documented and consented access, with retention rules set before the first pull.

Keeping it current

Markups are time-sensitive — a setup tagged active this morning may be closed by the afternoon. The mirror polls on an agreed cadence, dedupes by markup id and publish time, and updates the status field rather than duplicating a markup when its state changes. Freshness, not volume, is the constraint, so the cadence is tuned to how often Hidden Wealth Society posts, not to a fixed clock.

In-app screens

Reference screens from the listing, useful for confirming the surfaces above. Tap to enlarge.

Neighbouring apps in the same space

Other tools traders pair with a markup feed, for context on a unified integration. Plain references, no ranking.

• WealthCharts — a charting platform with its own mobile app, holding watchlists, indicators, and saved chart layouts.
• TradingView — charts, saved ideas, and alerts, where annotated markups and published ideas live behind an account.
• Elite Signals — indicator-driven buy and sell signals with a members area and watchlists.
• 3Commas — signal, DCA, and grid bots that consume external signal feeds for automated execution.
• Learn2Trade — a signals channel built on technical analysis, distributing entries and targets to members.
• Cornix — parses formatted signal messages and routes them to an exchange, so a structured feed maps onto it directly.
• Trasignal — forex and crypto alerts paired with chart screenshots and entry/exit points.
• AltAlgo Indicator — a TradingView script plus alert delivery to members.

How this was checked

I read the app's Google Play listing for the feature set and package id, the Hidden Wealth Society site for what the community publishes, and third-party write-ups for the membership tiers and pricing, in May 2026. The integration route follows from the app being a login-gated, image-first markup feed rather than from any single document.

• HWS Chart Viewer on Google Play
• Hidden Wealth Society
• Hidden Society membership review (Whop)
• Google Play Data safety reference

OpenBanking Studio integration desk — mapping reviewed May 2026.

Questions an integrator tends to ask

Does the feed carry the category and status tags, or only the chart images?

Both, when the route is built right. The annotated chart is the primary artifact, but the app groups markups by market type, pairing, order type, and chart status. We capture those fields alongside each image so downstream filtering matches what a member sees in the app, rather than handing you a folder of pictures with no metadata.

Can an external archive stay in step with the in-app "load previous days" view?

Yes. We model the backfill the same way the app pages older markups, key each item by its server id and publish time, and dedupe on re-sync. That keeps a searchable mirror that includes setups posted between two polls, not just whatever was on screen at the last check.

The markups are Hidden Wealth Society's own work — how is that handled?

The integration runs under your authorization and against access you are entitled to, and we keep to documented, consented use. The markups stay Hidden Wealth Society's intellectual property; we move them into your own stack for your own use, with retention and access rules agreed up front and an NDA where you want one.

We are on the free Hidden Hub tier rather than the paid membership — what is reachable?

Exactly what that account is entitled to see, no more. The session is driven by your own credentials, so a free-tier login reaches free-tier content and a paid membership reaches the full markup feed. We scope the build to the tier you bring and note clearly where a higher tier would widen coverage.

The work ships one of two ways, and the price is the simple part. Source-code delivery starts at $300: you get runnable source for the markup endpoints, the spec, tests, and documentation, and you pay after delivery once it works for you. Or run it as a pay-per-call hosted API — no upfront fee, you pay only for the calls you make. Either way the cycle is one to two weeks. Tell us the app and what you want out of its feed and we handle the access, the build, and the compliance side — start at /contact.html.