Getting a user's portfolio out of My Stocks Portfolio

My Stocks Portfolio keeps a user's holdings on the phone by default — the records only reach Peeksoft's servers once that person turns on account sync. That single design choice, stated in Peeksoft's own privacy policy and backup help guide, decides everything about how you get the data out. The portfolio is rich: listed stocks, ETFs, funds, currencies, crypto, and unlisted equity, with per-lot cost basis, realized and unrealized gains, multi-currency conversion, watchlists and price alerts. The integration question is narrow and answerable. How do you pull one account's portfolio, in a normalized shape, on the cadence a consumer needs?

Bottom line: this is not a bank, and no account-aggregation regime sits between you and the data. The data belongs to the account holder, and there are two clean ways to it — the export Peeksoft documents, and the sync channel the app already uses. We build whichever fits the freshness you need, normalize the multi-asset mess into one schema, and hand back source you can run.

What My Stocks Portfolio keeps, and where

Every row below is a real surface of the app, named close to how the app presents it. Granularity matters here because the value is in the lots, not just the totals.

Routes into the synced portfolio

Three apply to this app. None of them touches authentication you are not entitled to use — each runs against an account whose owner has consented.

Documented CSV export

The app writes a CSV backup to Google Drive, external storage, an SD card, or email — Peeksoft documents this in its backup guide. With the account owner's consent we read that file from the linked Drive folder or mailbox and parse it into the normalized schema. Effort is low. Durability is high because the export format is a documented, stable artifact. The trade-off is cadence: it refreshes when the user (or a scheduled export) produces a file, not continuously.

Authorized sync-protocol integration

The app's server sync performs a safe merge — it uploads local data the server lacks and downloads server data the device lacks. With the account holder's authorization we analyze that traffic, implement the pull side read-only, and run incremental fetches keyed off the sync cursor. Effort is moderate; durability is moderate because it tracks the app's own protocol. This is the route when a consumer needs near-live holdings rather than a daily file.

User-consented session access

Where the owner prefers, they consent to us operating the account's sync session on their behalf, strictly as a read-only mirror. It sits between the other two on effort and tracks whatever auth flow the account uses.

For most reporting and tax work the CSV export is the spine — cheap, documented, hard to break — and the sync-protocol pull is layered on only when the use case genuinely needs continuous freshness. We say which one we'd build after we see what cadence your consumer needs; the recommendation is rarely both on day one.

What ships for this build

Concrete artifacts, each tied to a real surface above:

• An OpenAPI specification for a normalized portfolio-read API — holdings, lots, portfolios, watchlists, performance, FX, alerts.
• A protocol and auth-flow report: the account session/token chain of the sync endpoint, or the CSV-pipeline mechanics, written up as the app actually behaves.
• Runnable source in Python and Node.js — the pull, the CSV parser, and the multi-asset normalizer.
• Automated tests that run against recorded response and CSV fixtures, so a protocol change is caught, not discovered in production.
• Interface documentation an engineer can hand to a teammate.
• Data-retention and consent guidance matched to Peeksoft's privacy posture, including the US-hosting note.

The sync handshake, in practice

Illustrative shape only — exact paths, fields and auth are confirmed during the build against a consenting account, then frozen into the report.

# Authorized read-only pull keyed off the sync cursor
POST /sync
  Authorization: <account session token>
  body: { "since": "<cursor>", "device": "<mirror-id>" }

# Response (safe-merge delta) -> normalized before it leaves the adapter
200 {
  "portfolios": [ { "id": "...", "name": "Long-term", "baseCurrency": "USD" } ],
  "holdings": [
    { "symbol": "AAPL", "exchange": "NASDAQ", "assetType": "equity",
      "qty": 40, "costBasis": 5120.00, "currency": "USD",
      "lots": [ { "date": "2023-09-11", "qty": 40, "price": 128.00 } ] },
    { "symbol": "BTC", "assetType": "crypto", "qty": 0.35, "currency": "USD" }
  ],
  "watchlists": [ { "name": "Energy", "symbols": ["SHEL","XOM"] } ],
  "alerts": [ { "symbol": "TSLA", "above": 260.0 } ],
  "fx": { "base": "USD", "rates": { "EUR": 0.92, "GBP": 0.79 } }
}

# Documented CSV fallback — one row per lot, parsed to the same schema
symbol,exchange,assetType,quantity,price,costBasis,currency,portfolio,tradeDate
      

If sync is off on the account, none of this exists server-side yet — the CSV path then carries the whole job, which is exactly why we check sync state first.

Where this plugs in

• A wealth dashboard that needs a client's full multi-asset position, crypto included, refreshed nightly from the CSV export.
• A tax tool that needs per-lot cost basis and trade dates to compute realized gains for a filing period.
• A rebalancing service that consumes allocation weights and target base currency to propose trades.
• A monitoring layer that mirrors the user's own price alerts so notifications fire in one place.

Consent and the data-protection footing

The portfolio is the account holder's own data, so the consent basis is theirs to give — there is no payment regulator or aggregation scheme in the path. Peeksoft's privacy policy is the document that governs it: account information such as name, username and email is stored on US servers and may be held on equipment in other countries, sensitive financial data is not shared with third parties without consent, and stored data is anonymized so an unauthorized read is not linkable back to a person. The policy applies GDPR for EU users and is explicit that data crosses into a jurisdiction without equivalent protection. We operate to match that: access is authorized and logged, the pull is read-only and never triggers the app's "delete local data before syncing" path, only the fields a use case needs are taken, and an NDA is in place where the client wants one. Consent is recorded with scope and an expiry, and a revocation stops the pull and removes the mirror.

Engineering detail we take care of

Things specific to this app that we design around, so you do not have to:

• Default-local storage. The server only holds a portfolio after the user enables sync. We confirm sync is on for the consenting account, or run the CSV path, so the build is never integrating against an empty mirror.
• Safe-merge semantics. The app's sync uploads local-only data and downloads server-only data, and offers a destructive "delete local before syncing" option. Our pull is strictly the read side and never asserts itself as the authority, so a user's device state is untouched.
• Premium-gated auto-sync. Automatic syncing is a paid tier; otherwise the account syncs on a manual tap. We pace the pull to the cadence the account's tier actually supports rather than assuming a continuously fresh server copy.
• Multi-asset identifiers. Listed names carry ticker plus exchange, crypto carries a symbol, unlisted equity is free text. We resolve these to one instrument model and keep native trade currency alongside a normalized base so no FX snapshot gets baked in.
• Protocol drift. When Peeksoft revises the sync payload or the export columns, the adapter needs a quick conformance check; we keep a fixture set of recorded responses and re-run it against the live endpoint as part of upkeep.

Keeping holdings and quotes current

Two clocks run here. Portfolio structure — what is held, at what cost — changes only when the user edits it, so the CSV path keeps that current at whatever schedule its export runs. Quotes and FX move continuously; Peeksoft lists IEX Group, Alpha Vantage, Tradier, CoinGecko and CryptoCompare among its market-data partners, and those values are recomputed inside the app. We treat positions and prices as separate freshness contracts in the interface docs so a consumer is never guessing how stale a number is.

What was checked

This mapping was built by reading Peeksoft's privacy policy, its backup-and-switching-devices help guide, the Peeksoft site's stated market-data partners, and the public store listing for the app, in May 2026. The notable finding driving the route choice is that storage is local-first and server sync is explicit opt-in. Primary sources:

• Peeksoft privacy policy
• My Stocks Portfolio backup & device-switch guide
• Peeksoft — features and data partners
• Google Play listing (co.peeksoft.stocks)

OpenBanking Studio — integration desk · portfolio-sync mapping, 2026-05-17.

Other portfolio trackers in the same orbit

Named for ecosystem context — a unified integration usually has to speak to more than one of these.

• Delta — tracks stocks, ETFs and crypto from manual entry plus some broker connections; holds positions and performance server-side.
• Sharesight — performance and tax reporting across many international exchanges; holds trade history and dividend records.
• Snowball Analytics — dividend and target-allocation tooling; holds portfolios with rebalancing targets.
• Kubera — net-worth tracker spanning listed and private assets; holds aggregated balances.
• Yahoo Finance — portfolios, watchlists and alerts inside a broad market app; holds account-linked lists.
• Stock Events — mobile-first tracking with widgets and events; holds positions and dividend calendars.
• Stock Rover — research-heavy tracking for complex portfolios; holds holdings and screening state.
• Seeking Alpha — research platform with a portfolio tracker; holds watchlist and holding records.
• Empower — free net-worth and investment tracking; holds linked-account aggregates.

Screens we mapped

Tap to enlarge. These are the surfaces the data domains above were read from.

Questions integrators ask about this one

Does a user's portfolio live on Peeksoft's servers, or only on the phone?

By default the records stay on the device. Per Peeksoft's privacy policy and its backup help guide, holdings only reach the account sync server once the account holder turns sync on, and Peeksoft does not auto-back-up for privacy reasons. We confirm sync state on the consenting account before integrating, or take the documented CSV export path when sync is off.

How do you reconcile listed stocks, crypto and unlisted equity that sit in one portfolio together?

The app mixes listed equity, ETFs, funds, FX positions, crypto and free-text unlisted holdings, each carrying a different identifier. We normalize them to one instrument schema — ticker plus exchange for listed names, symbol for crypto, an opaque label for unlisted — so a downstream consumer sees a single consistent shape with the native trade currency preserved.

Auto-sync is gated behind Peeksoft's premium subscription — does that affect the build?

It changes cadence, not feasibility. Without premium, the account syncs on a manual tap; with it, sync can run automatically. We schedule the pull around whatever cadence the consenting account's tier allows rather than assuming a continuously fresh server mirror, and we say so in the interface docs.

We only need a periodic snapshot for tax and reporting — what is the lightest path for My Stocks Portfolio?

The documented CSV export. The app writes a backup to Google Drive, external storage or email; with the account owner's consent we read that file on a schedule and parse it into the normalized portfolio schema. It is the lowest-effort, most durable route for batch reporting and needs no protocol work.

Source delivered for this app is a runnable portfolio-read service plus its OpenAPI spec, the sync-or-CSV protocol report, automated tests and interface docs — priced from $300 and paid only after delivery, once you have checked it works. Prefer not to run anything yourself? The same extraction is available as a hosted endpoint you call and pay per request, with nothing upfront. Either build runs in one to two weeks. Tell us the app and what you need from its portfolio data at /contact.html, and access for the consenting account is arranged with you from there.