A feed of ShopeePay balances, transfers and bill payments

ShopeePay keeps a rolling twelve-month record of every wallet movement, split into Money In and Money Out, and that ledger is what most integrators come to us to reach. The wallet links a Vietnamese bank account or debit card, runs top-ups and bill payments, and moves money between contacts — all behind an authenticated session inside the wider Shopee app. The job is to get a clean, normalized feed of that activity out of the app and into your systems, on a schedule, under the account holder's consent.

Here is the short version. ShopeePay is an e-wallet, not a bank, so its data sits in the wallet ledger rather than in a bank statement. The richest surface is the in-app history feed; the funding bank account behind it is a second, separate target. We build against the wallet session because that is where the Money In/Money Out detail, pending transfers and bill-payment records actually live.

What sits behind a ShopeePay account

Each row below is a surface the app exposes to its own user. Fields named the way the app labels them, where the Shopee help documentation makes that visible.

Routes to the data

Three approaches genuinely apply to this app. They reach different things.

Authorized interface integration under consent

We analyze the wallet session the way the app's own client uses it, with the account holder's authorization, and read the balance and the Money In/Money Out feed directly. This is the only route that returns the full wallet ledger — pending states, transfer counterparties, bill-payment detail. Effort is moderate; durability depends on the app's front end, which is why we build in re-validation (see below). Access is arranged with you during onboarding and the build runs against a consenting account.

Bank-side Open API on the funding account

Because every wallet links a Vietnamese bank account or debit card under Decree 52, that bank account can be reached through the SBV's Open API consent regime as banks bring it online. This is durable and regulated, but it gives you the funding rail, not the wallet's own ledger. We wire it as a complement where a client also needs the bank side.

User-consented in-app export

The app's own twelve-month history can be captured directly for a one-time reconciliation. Low effort, no live sync, and it ages out at the twelve-month edge. Useful as a starting snapshot, not as a running feed.

For ShopeePay the interface route is the one we actually build: the wallet's Money In/Money Out ledger and pending-transfer states only exist inside the app session, so neither the bank-side consent rail nor the manual export reaches them. The other two earn their place as a complement and a quick snapshot, not as the working path.

Where Vietnamese e-money rules land on this

ShopeePay operates as an intermediary payment service under Decree 52/2024/ND-CP, the decree that gave Vietnam its first legal definition of e-money and took effect on 1 July 2024 (per Vietnam-Briefing's reading of the decree). Two consequences matter for an integration. The wallet must be linked to a customer's bank account or debit card, which is why the funding instrument is a real, separate data surface. And the operator is licensed and supervised by the State Bank of Vietnam, so anything we build sits on top of the user's own authorization and is logged accordingly.

The SBV's Open API rule, Circular 64/2024/TT-NHNN, is sometimes assumed to cover wallets too. It does not — it applies to commercial banks and phases bank APIs in over staged windows from its effective date, built on user consent with revocation and a security level of grade 3 or higher (per Tilleke & Gibbins' summary of the circular). For ShopeePay that means the wallet ledger is reached through consented interface integration, while the linked bank account is what can travel over the bank Open API regime. Consent on our side is scoped to the surfaces a project needs, time-bound, revocable, and recorded; we minimize the fields pulled and work under NDA where a client requires it.

What we plan around on this app

Concrete things this specific build has to account for, handled on our side:

• Session and token lifecycle. The wallet sits inside the Shopee session, behind two-factor and biometric login per the app's security description. We map the token refresh and the re-authentication step so a long history pull does not drop mid-run when a short-lived token ages out.
• The twelve-month horizon. Native history reaches back about a year. For clients who need longer retention we run an incremental backfill that stores each row on your side before it falls out of the in-app window, so your record outlasts the app's.
• Two ledgers, kept reconcilable. Because Decree 52 ties the wallet to a bank account or card, we model the wallet ledger and the funding-account rail as separate but linkable, so top-ups reconcile cleanly against the funding source.
• Locale normalization. Amounts are VND and biller and merchant labels are Vietnamese. We normalize currency, status values and counterparty labels into a stable schema, and wire a re-check into maintenance for when the app's front end shifts.

What ships at the end

Everything is tied to the surfaces above, not a generic template:

• An OpenAPI/Swagger specification for the balance and wallet-history endpoints as modeled for this app.
• A protocol and auth-flow report covering the session, token refresh and the 2FA/biometric step.
• Runnable source in Python or Node.js for the balance read and a paginated Money In/Money Out pull, normalized to a VND transaction schema.
• Automated tests, including token-refresh recovery and pagination edge cases.
• Interface documentation plus the normalized schema (Transaction SN, Reference ID, amount, status, completed time).
• Compliance and retention guidance: consent records, data minimization, and the bank-rail boundary under Decree 52.

The history pull, in code

Illustrative only — exact field names are confirmed during the build, not copied from any private interface.

# wallet session is established after the user's 2FA / biometric step
token = session.access_token            # short-lived; refreshed on 401

def wallet_history(cursor=None, flow="OUT"):
    r = client.get(
        "/wallet/v1/transactions",
        params={"flow": flow,            # "IN" -> Money In, "OUT" -> Money Out
                "cursor": cursor,        # forward pagination
                "window": "12m"},        # native history horizon
        headers={"Authorization": f"Bearer {token}"},
    )
    if r.status_code == 401:             # token aged out mid-pull
        refresh()
        return wallet_history(cursor, flow)

    page = r.json()
    for txn in page["items"]:
        yield {
            "sn":         txn["transaction_sn"],   # Transaction SN
            "ref":        txn["reference_id"],      # Reference ID
            "amount_vnd": txn["amount"],
            "status":     txn["status"],            # Successful / Refunding / Failed / ...
            "completed":  txn["completed_time"],
        }
    if page.get("next_cursor"):
        yield from wallet_history(page["next_cursor"], flow)

Common builds teams ask for

• Nightly bookkeeping sync. Pull Money Out into an accounting ledger each night, categorized by biller and merchant, so wallet spend lands in the books without manual entry.
• Top-up reconciliation. Match ShopeePay cash-ins against the linked bank account's outgoing transfers to close the loop on float movement.
• Spend analytics. Roll merchant and partner payments — transport, food, entertainment, shopping — into category dashboards for a finance or expense tool.

Screens we worked from

Store screenshots used while mapping the surfaces. Tap to enlarge.

Other Vietnamese wallets in the same picture

Teams that integrate ShopeePay usually want one or two of these alongside it. Named for ecosystem context, not ranked.

• MoMo — the largest Vietnamese wallet, holding balances, P2P transfers, bill payments, micro-loan and investment records behind an account.
• ZaloPay — wallet tied to the Zalo messenger, with transfers, bill payments and e-commerce purchase history.
• Viettel Money — telco-backed wallet and mobile-money service with balances, transfers and a wide rural top-up footprint.
• VNPay — QR and bank-transfer focused, holding payment and VietQR transaction records across merchants.
• Moca (GrabPay) — payment layer inside Grab, with ride, food and merchant payment history.
• Payoo — bill-payment and top-up platform holding utility and service payment records.
• SmartPay — wallet aimed at small merchants, with payment acceptance and transaction data.
• Timo — digital banking app with account balances, statements and transfer history.
• VTC Pay — wallet and gateway with top-ups, gaming and bill-payment records.

A unified integration normalizes the same primitives across these — balance, dated transactions, transfers, top-ups — into one schema, which is exactly the shape we deliver for ShopeePay.

Questions integrators ask about ShopeePay

Does the wallet history reach back far enough for a full statement sync?

In-app, ShopeePay shows roughly the last twelve months of activity on the wallet home, split into Money In and Money Out. That window is enough for most live syncs, but rows older than the horizon drop off. When a client needs deeper retention we run an incremental backfill that captures each row and stores it on your side before it ages out, so your own history outlives the app's twelve-month view.

ShopeePay runs inside the Shopee super-app — can the wallet data be isolated on its own?

Yes. The wallet ledger, balance and transfer states are a distinct authenticated surface even though the user reaches them through the wider Shopee session. We map the session and token handoff so the integration reads only the wallet surfaces it needs — balance, the Money In/Money Out feed, top-ups, bill payments and transfers — and leaves the rest of the super-app alone.

Is ShopeePay covered by Vietnam's bank Open API rule, Circular 64?

Circular 64/2024/TT-NHNN targets commercial banks, not e-wallet operators. ShopeePay is an intermediary payment service under Decree 52/2024/ND-CP, so the wallet's own ledger is reached through authorized interface integration under the account holder's consent. The Vietnamese bank account or debit card that funds the wallet, under Decree 52 every wallet must be linked to one, can ride the SBV Open API consent regime separately as banks roll it out.

We can already export the twelve-month history from the app — why bring you in?

The in-app view is a manual snapshot: no live sync, no normalized schema, Vietnamese labels and VND amounts left as-is, and it ages out at the twelve-month edge. We deliver a maintained feed instead — balance plus a paginated Money In/Money Out pull normalized to a stable schema, with token refresh and pagination handled, so the data lands in your systems on a schedule rather than as a one-off download.

What was checked, and when

Mapped against the app's Google Play listing for package, developer and service set; the Shopee help documentation for the Money In/Money Out structure, the twelve-month window and the per-transaction fields (Transaction SN, Reference ID, status, completed time); and Vietnamese regulatory analysis for Decree 52 and Circular 64. Checked June 2026; the regulatory rollout is still moving, so treat dates as current at review.

Sources: Google Play listing, Shopee Help Center — viewing ShopeePay transaction history, Vietnam Briefing — Decree 52 and e-money, Tilleke & Gibbins — SBV Open API circular.

Mapped by the OpenBanking Studio integration desk · June 2026.

Getting it built

Source for the balance-and-history pull, normalized to a VND Money In/Money Out schema, ships in one to two weeks. You can take it as delivered code from $300, paid only once it runs against your account to your satisfaction; or skip the build and call our hosted endpoints, paying per call with nothing upfront. You give us the app name and what you need from its data — access and the compliance side are arranged with you as part of the work. Start at /contact.html and we'll scope it.