Syncing Hidden Wealth Society's chart markups out of HWS Chart Viewer

Behind HWS Chart Viewer sits one moving payload: the chart markups Hidden Wealth Society publishes for its forex and options members. Each markup is a setup — an instrument, an order type, and entry, stop and take-profit levels drawn over a price chart. The app's whole job is to render those markups, let you swipe through them, page back through previous days, and filter by market type, pairing, order type, or chart status. That repeating, faceted, time-stamped stream is exactly what an integrator wants to mirror into a store of their own, and it is what this page is about: the authorized way to read it, and the client we hand you to do it.

What the feed actually carries

Most of the value is in four surfaces the app already exposes to a logged-in member. The table maps each to where it originates and what a sync would do with it.

None of this is per-user financial data in the bank sense. It is published analysis the member has paid to view. That changes the compliance shape, not the engineering one.

Getting to the markups

Two routes genuinely fit this app, plus a floor option.

Protocol analysis on a consenting member session — recommended

We watch how the app's own client authenticates and fetches the markup list, the per-markup detail, the facet filters, and the previous-days pager, then rebuild those calls in a small client. Reachable: everything the member can see in the app. Effort is moderate — most of it is reading the auth handshake and the pagination correctly. Durability tracks the app: when Hidden Wealth Society ships an update that renames a field or moves an endpoint, the recorded tests flag it and we adjust. Access is arranged with you at onboarding using a consenting member's account, so nothing here waits on the vendor.

Member-consented credential access

Where you would rather the integration drive a login you control, the member supplies (or runs) their own credentials and the client holds the resulting session. Same surfaces reached; durability is tied to how the sign-in flow changes rather than to individual data endpoints. This is the cleaner fit when the consuming system is the member's own tooling.

Rendered-image capture — the floor

The markups are, at heart, annotated chart images. If a member only needs the picture for a given day, scripted capture of the rendered chart is the minimum viable path and a reliable fallback when a level exists only as a drawn line. We would not lead with it, but it is there.

For almost every brief here, the first route is the one worth building: it gives structured records, not pixels, and it survives app updates with a test suite watching the payload. We say which route we recommend in writing once we have seen one real response from your member session.

What lands in your repo

The headline deliverable is code that runs against your session, not a document about code.

• A runnable client (Python and Node.js). Authenticates as the consenting member, pulls the markup list, fetches per-markup detail, applies the facet filters, and walks the previous-days pager with a date cursor.
• An ingestion job. A scheduled poller that backfills the archive on first run and then fetches only the new day, writing markups into your store keyed by markup id.
• A recorded-fixture test suite. Real responses captured during the build become fixtures; if Hidden Wealth Society renames a field in the markup payload, those tests fail on the rename instead of the value quietly going missing.
• A normalized schema and field map. Raw markup payload to a clean record — instrument, market type, order type, status, levels, chart image, published-at.
• An OpenAPI description of the reconstructed surface and an auth-flow write-up (the token or cookie chain the app uses), for whoever maintains it after us.
• Interface documentation and a short data-retention note covering how the synced markups and any session data are stored and aged.

A first pull, in code

Roughly what the client looks like once the member session is in hand. Paths and field names are illustrative here and confirmed against real responses during the build.

# illustrative — against a consenting Hidden Wealth Society member session
from hws_markups import Client

hws = Client(session=member_session)          # the member's own authenticated session

# latest markups, narrowed by the app's own facets
page = hws.markups(status="active", pairing="XAUUSD", order_type="buy")
for m in page:
    print(m.instrument, m.order_type, m.entry, m.stop, m.take_profit, m.published_at)

# walk "load previous days" to backfill the archive
cursor = page.older_than                      # date cursor behind the previous-days control
while cursor:
    older = hws.markups(before=cursor)
    store.upsert(older.records, key="markup_id")   # keyed by markup id
    cursor = older.older_than

# session handling: a 401 means re-authenticate as the member, then retry once

The numeric levels are read as the markup presents them. Where entry, stop or target is only a line on the chart rather than a field, the client records the chart image and tags that level image-derived, so nothing downstream treats a missing number as zero.

How a markup normalizes

The store-side shape we standardize to, so the four data domains above collapse into one queryable record:

{
  "markup_id": "…",
  "instrument": "XAU/USD",
  "market_type": "forex",
  "order_type": "buy_limit",
  "status": "active",
  "levels": { "entry": null, "stop": null, "take_profit": [] },
  "level_source": "field | image",
  "chart_image_url": "…",
  "published_at": "2026-06-08T00:00:00Z",
  "source": "Hidden Wealth Society"
}

The level_source flag is the honest part: it records whether each number came from a structured field or was read off the rendered chart, so you can decide which setups are safe to alert on automatically.

What we plan around in this app

A few specifics about HWS Chart Viewer shape how we build, and we handle each rather than hand it back to you.

• Levels can live in the image. A chart markup is a drawing first and a data record second, so entry, stop and target may be annotations rather than fields. We map every structured field the payload exposes and, for anything that is only drawn, capture the image and flag it — no guessed numbers in your store.
• Access is subscription-gated. The premium tier runs at $19.99 a month per the App Store listing. We run the build against a consenting member's session set up with you during onboarding, so the client authenticates exactly as the app does and never reaches beyond what that member has paid to see.
• The pager defines the archive depth. The "load previous days" control sets how far back history goes. We size the backfill to that window and the publish cadence, so the first sync grabs the full backlog and later runs touch only the new day.
• The catalog is faceted. Market type, pairing, order type and chart status are how the app organizes markups, so we model them as first-class fields. Filtering for, say, only active buy setups on one pairing works in a query rather than by re-reading every record.

Whose data, whose permission

HWS Chart Viewer is a content subscription from a US operator — Hidden Wealth Society of Georgia LLC, per its App Store listing — not a money-holding institution, so no open-data or account-aggregation scheme governs it. The dependable legal footing is the member's own authenticated, paid access and their consent to mirror what they already see. We build on that and document it.

The markups themselves are Hidden Wealth Society's intellectual property. We scope every integration to a consenting member's own use and interoperability, under NDA, and we do not redistribute or resell the content. Where the consuming system or its users sit in the EU or UK, GDPR and UK GDPR apply to any personal data carried in the member session; we minimize that by storing markup content rather than member identity, and we log access so the consent trail is auditable. The App Store privacy label states the developer collects no data through the app, which we treat as a reason to keep our own footprint just as small.

Screens we mapped against

The published store screenshots, used to confirm the markup layout, the facet filters and the day-by-day navigation. Select to enlarge.

Charting peers worth a unified read

If you are consolidating chart analysis from more than one source, these come up in the same category. Named for context, not ranked.

• WealthCharts — a charting and scanning platform with exclusive signal scanners; its setups would line up beside the HWS markups in one view.
• TradingView — hosts user and creator chart ideas with published levels; the normalized markup shape above maps cleanly onto its idea feed.
• TrendSpider — automated pattern detection and alerting across stocks, options, futures, forex and crypto; its alerts can land in the same signal store.
• ChartingLens — surfaces buy/sell signals and pattern recognition; comparable per-setup fields to normalize.
• GoCharting — real-time crypto and equity charts with embedded trading; another source of dated chart annotations to sync.
• Koyfin — financial data and customizable charts; useful when you want market context next to the markups.
• StockCharts — chart annotation and analysis aimed at retail traders; similar markup-style content to consolidate.
• MetaTrader 5 — forex and algo execution, where forex setups like the HWS markups often get acted on.
• NinjaTrader — futures and active-trading desktop; the execution end of a markup-to-trade workflow.

Questions integrators ask about HWS Chart Viewer

HWS publishes markups through the trading day — how fresh can the synced copy be?

The client polls the same list the app reads when you open it, on the cadence Hidden Wealth Society publishes, so a new markup shows up in your store within one poll interval. The first run walks the load-previous-days pager to backfill the archive; after that only the new day is fetched, keyed by markup id, so the sync stays incremental.

Do the entry, stop and take-profit levels arrive as numbers or only as chart images?

Whatever the payload carries as structured fields comes through structured. Where a level lives only as a line drawn on the rendered chart, the client captures the chart image and marks that level image-derived rather than inventing a number. We tell you per field which is which during the build.

Whose login does the integration run on?

A consenting Hidden Wealth Society member's own subscription session, arranged with you during onboarding. The client authenticates exactly as the app does and stays inside what that member is entitled to see; it does not reach content the subscription has not paid for.

The markups are Hidden Wealth Society's own work — is mirroring them into our tools acceptable?

We scope the integration to a consenting member's own use and interoperability, under NDA, storing the markup content the member already sees and minimizing any personal data in the session. We do not redistribute the markups or resell access; how you use the synced setups inside your team is bounded by your subscription terms.

Getting a client built

A first client that authenticates as your member account and pulls the live markup list plus a dated backfill is a one-to-two-week build. Source-code delivery starts at $300, billed only after the client runs against your session and you are satisfied with it. If you would rather not host anything, the same integration is available as a pay-per-call hosted endpoint with nothing paid up front — you call it, you pay for the calls. Tell us the app and what you want out of its markups at our contact page and we will name the route and the shape of the deliverable from one real response.

Sources and who checked them

Checked in June 2026 against the app's own store listings and the operator's site: the App Store entry for developer, price, category and rating; the Hidden Wealth Society site for the forex-and-options education model; and the Google Play listing for the package and feature copy. Where a detail is not publicly disclosed — exact endpoint paths, the markup payload's field names — it is not asserted here and is confirmed only during the build.

• HWS Chart Viewer on the App Store
• HWS Chart Viewer on Google Play
• Hidden Wealth Society

OpenFinance Lab — interface assessment, 2026-06-08.