Reaching Vantage's two data backbones: MetaTrader and the client portal

Trade tickets, ledgers, copy-trading subscriptions and V-Wallet movements do not all live in the same place inside Vantage. The deal history sits on the MetaTrader 4 or MetaTrader 5 trade server that books your account; the wallet, the deposit and withdrawal history, the KYC documents and the social copy-trading subscriptions sit on the Vantage client portal at secure.vantagemarkets.io. An integration that misses one side of that split returns a partial answer. The brief below is how we map both sides into one normalized feed.

What sits inside Vantage, and where

This is the row set we plan an integration around. The granularity column is what the source actually carries — not a wish list.

The routes that actually apply

Three credible paths into Vantage, plus a fallback. We recommend in plain language at the end of this section.

1. MetaTrader Manager / FIX path (via Vantage Connect)

Vantage publishes an API surface under its institutional product, Vantage Connect, that exposes market data and trade execution over the FIX protocol and integrates with MT4 / MT5 bridge technology (per the Vantage Connect API solutions page). Where the client controls a Vantage Connect arrangement, this is the cleanest path: MetaQuotes' schema is stable across years, the field names do not drift, and trade history pulls cheaply. Onboarding paperwork is something we run with you during the engagement.

2. Authorized client-portal integration

The portal at secure.vantagemarkets.io is where everything outside the trade ledger lives — V-Wallet history, deposit and withdrawal records, KYC documents, copy-trading social. We map the authentication flow (session cookie plus a rotating CSRF token), enumerate the AJAX / REST calls behind the visible pages, and document request and response shapes. The build runs against an account the client controls or a Vantage-issued sandbox, arranged with you during onboarding.

3. MetaTrader native HTML / CSV statement export

The MT4 and MT5 terminals let you right-click account history, choose Custom Period, then export the report as HTML or CSV (per Vantage's own help-centre article on generating trading account statements). We treat that as a redundancy: parsers normalize it into the same schema we use for the live feeds, so the integration keeps working even if Vantage Connect is briefly unreachable or a portal-side change is in flight.

4. User-consented credential access (single-trader scope)

For individual traders without an institutional contract, we wrap the portal session in a consent-recorded flow. Credentials stay inside the consent boundary, the scope is narrowed to specific domains (e.g. only deals and only V-Wallet, not KYC documents), and a revocation hook is part of the deliverable.

The route we'd actually pick. Where Vantage Connect is in scope, the Manager / FIX spine pulls the trade ledger; the portal route pulls everything around it; statement export sits behind both as a fail-safe. Where Vantage Connect is not in scope, the portal route becomes the spine, with statement parsing as the redundancy and a narrower data set. We pick during the discovery call, not in advance.

A worked example: V-Wallet transactions

Illustrative — exact paths and field names are confirmed during the build, since the client portal rotates a CSRF token per session and the response shape sometimes shifts ahead of a UI rollout. The pattern, however, is what we deliver.

import httpx

PORTAL = "https://secure.vantagemarkets.io"

async def fetch_v_wallet_history(session: httpx.AsyncClient,
                                 account_id: str,
                                 frm: str,   # ISO 8601
                                 to: str):
    """Yield wallet entries against one MT account, paged in 200s."""
    cursor = None
    while True:
        params = {"accountId": account_id, "from": frm, "to": to, "size": 200}
        if cursor:
            params["cursor"] = cursor
        r = await session.get(f"{PORTAL}/api/v1/wallet/transactions",
                              params=params)
        r.raise_for_status()
        body = r.json()
        for tx in body.get("items", []):
            yield {
                "ts":         tx["createdAt"],   # UTC, ISO 8601
                "type":       tx["type"],        # DEPOSIT | WITHDRAWAL | TRANSFER_IN | TRANSFER_OUT
                "currency":   tx["currency"],    # one of 8 base currencies the app offers
                "amount":     tx["amount"],
                "mt_account": tx.get("toAccount") or tx.get("fromAccount"),
                "method":     tx.get("method"),
                "status":     tx["status"],      # PENDING | SETTLED | REJECTED
                "reference":  tx.get("reference"),
            }
        cursor = body.get("nextCursor")
        if not cursor:
            return

# 401 / 419 → re-auth; 429 → respect Retry-After; portal occasionally
# returns 200 with an error envelope, so check body["ok"] before paging on.

The same pattern applies to deals, open positions and copy-trading subscriptions; only the path and the field dictionary change. Errors fan out into three buckets we always handle — re-auth, throttling, and the “200 OK with an error envelope” case the portal sometimes returns.

What lands in your repo

• An OpenAPI 3.1 specification covering each portal endpoint we touched, plus a separate FIX session profile if the Manager path is in scope.
• A protocol and auth-flow report: how secure.vantagemarkets.io issues the session cookie and CSRF token, where the rotation hook sits, and how the MetaTrader trade server is reached when Vantage Connect is in play.
• Runnable source — Python (httpx + pydantic) or Node (axios + zod) — for the seven domains listed above: deals, positions, account state, deposits / withdrawals, V-Wallet, copy-trading subscriptions, symbol specs.
• Statement parsers for the MT4 and MT5 HTML / CSV export, with golden-file fixtures so a future Vantage report-format tweak is caught by a failing test, not by silence.
• A test suite — unit tests over recorded fixtures plus a smoke test that hits a consenting account on a scheduled run.
• Interface documentation: sequence diagrams of login → CSRF → call, a field dictionary per domain, and retry / throttle notes per surface.
• A compliance pack: consent record template, data-minimization map per domain, default retention windows, and the entity-of-record tag (see below).

Authority, consent, and which entity is actually on the contract

Vantage Global Limited holds VFSC licence 700271 (per the Vanuatu register and the broker's own regulations page). The Vantage brand also operates regulated entities elsewhere — ASIC in Australia and FSCA in South Africa among them — and an account holder's actual books-and-records entity depends on the jurisdiction they signed up under. None of this sits inside a consumer-data-rights scheme: CFD trade-ledger data is not in scope of Open Banking, CDR, or the CFPB Personal Financial Data Rights rule (the §1033 framework is, as of this writing, not in force and is back in agency reconsideration — it is also not the right shape of rule for a brokerage in any case). The dependable basis for an integration is therefore the customer's own written authority to access the trading account, scoped per data domain, time-limited, and stored alongside the build. Privacy obligations follow the user's jurisdiction — typically GDPR for UK and EU residents, the equivalent local statute elsewhere.

Things we account for in a Vantage build

These are the engineering judgements we apply on every project against this app — written so you can see what we'd do, not as homework for you.

1. Two backends, one normalized record. The deal lives on MetaTrader; the funding origin behind that deal lives on the V-Wallet on the portal. We design the schema so a single trade row carries both views — pulling only one side leaves an integration that looks complete and silently is not.
2. Portal session rotation. The secure.vantagemarkets.io session uses a rotating CSRF token; long-running syncs need to refresh it cleanly rather than restart. We wire that into the HTTP client and keep a re-validation pass in maintenance so a Vantage UI rollout that briefly reshapes the request body does not silently halve the dataset.
3. Copy-trading mode matters. The three copy modes Vantage offers — Equivalent Used Margin, Fixed Lots, Fixed Multiples — attribute P&L differently between follower and provider. Reports built on raw deal rows misattribute unless the mode is encoded as a first-class field, so we surface it that way from the schema up.
4. Entity-of-record tagging. Vantage Global Limited's Vanuatu licence has been the subject of regulator action in the past (an October 2022 VFSC notice of intention to revoke, per OffshoreAlert; the licence is reported as still active in current broker-review coverage). We tag every row with the booking entity so downstream reporting does not assume one regulator's umbrella when the account books to another, and so a future entity change is a labelling event rather than a silent miss.
5. Symbol specs are not static. Swap rates and trading-hours rules on the MT instrument catalogue shift; we pull symbol specs on a schedule rather than pinning them at build time, so cost analytics keep matching what the trade actually paid.

Sources and review notes

What we checked while writing this: Vantage's Play Store and App Store entries for the app surface and the package ID; the broker's own Vantage Connect API solutions page for the FIX route; the Vantage help-centre article on generating MT4 / MT5 statements; the broker's regulations page and the VFSC licence number; and third-party broker-review coverage for entity history. The four citations below are the ones most worth opening.

• Play Store listing for Vantage:All-In-One Trading App (cn.com.vau)
• Vantage Connect — API solutions (FIX market data and execution)
• Vantage Help Centre — generating trading account statements
• Vantage Markets — regulations and licensed entities

Reviewed May 2026 by the OpenBanking Studio integration desk.

Where Vantage sits among CFD broker apps

Each of these competes for the same retail and pro-retail CFD audience and presents broadly the same integration surface — a MetaTrader (or proprietary) trade server plus a branded client portal. We list them so you can see the shape of a unified, multi-broker integration; this brief takes no view on which broker any given user should choose.

• Interactive Brokers — a global multi-asset broker whose IBKR Mobile sits on top of the firm's own TWS-grade API; the integration target is the Client Portal Web API rather than MetaTrader.
• IG — UK-listed CFD and spread-betting house with a documented REST API for its own platform; integration shape resembles a portal route more than an MT path.
• eToro — best known for its copy-trading social layer; portfolios and follow relationships are the headline data domain, plus the underlying trade ledger.
• XTB — proprietary xStation 5 platform with its own connector surface; CFD trade history and account state are the same kind of records but a different protocol.
• Fusion Markets — Australian-regulated CFD broker on MetaTrader; the closest structural twin to Vantage from an integration angle.
• Global Prime — another Australian MT broker; same trade-server pattern, different client-portal surface.
• City Index — StoneX-owned, multi-platform; its own web platform sits beside MT options.
• FP Markets — MT4 / MT5 broker with cTrader as an alternative venue; integration spans both protocols.
• Capital.com — proprietary platform with a public REST API; integration shape leans toward portal more than MT.
• Exness — large-volume MT broker; same backbone shape, larger account counts to plan throughput around.

Questions integrators ask first

Do you pull from MT4 and MT5, or only the newer platform?

Both. The Manager and FIX surface differs slightly between the two, but the normalized schema we deliver merges them, so the same account on MT5 ProTrader and a legacy MT4 carry-over reconciles into one row set.

Where does the copy-trading data come from — the Vantage portal or the trade server?

The provider list, follow status and copy-mode settings come from the Vantage client portal's social module; the deal records they generate land in the MT5 history and are linked back by ticket comment or magic-number convention.

What is the cleanest way to keep V-Wallet movements reconciled with trading-account ledgers?

Pull both feeds on the same window, key on the wallet transaction's toAccount / fromAccount field, and roll up to the MT account number. That reconciliation rule ships as part of the deliverable, not as homework.

Does the booking entity matter for what we can integrate?

The Vanuatu, Australian and UK entities expose roughly the same client-portal surface, but the books, the regulatory disclosures and some product availability differ. We read the entity off the account record and tag every row, so downstream reporting does not silently assume one regulator's umbrella when the account books to another.

Starting a Vantage build

A typical Vantage integration lands in one to two weeks as a working repository plus the documentation around it. Source-code delivery starts at US$300, paid only after we've handed it over and you've checked it works on your data. The pay-per-call hosted API has no upfront fee — you call our endpoints and pay only for the calls you make, useful when you want the integration to exist without owning the code. To start, tell us the app and the data you need from it; we'll write back with the route we'd take and a delivery date. Access, sandboxes and any consent paperwork are arranged with you during onboarding — they are part of the build, not a checklist to clear first.