Consent-first · Revocable anytime · Nothing raw ever leaves

Your customers' financial life already arrives in their inbox. Turn it into product.

FinLens is the consented email-intelligence platform. Users connect their mailbox through a hosted consent flow, FinLens parses their financial emails server-side — statements, policies, folios, subscriptions — and your app receives clean, typed insights through SDKs and APIs. You never touch tokens or raw email.

Integrates in a day with @finlens/web · @finlens/react-native · finlens_flutter · @finlens/node

< 5 minfrom consent to first insight
60+institutions covered — banks, insurers, AMCs, depositories
2-layerconsent, independently revocable, immutably logged
0raw emails exposed to partners — by schema, not policy
How it works

Three steps to email intelligence

FinLens carries the entire acquisition and parsing burden — mailbox OAuth verification, annual security assessments, parser maintenance — so integrating apps inherit the capability through a thin SDK.

1

Your user consents

Your app opens the hosted FinLens Connect flow in the system browser. The user sees exactly what will be read (financial senders only — the list is one tap away), grants mailbox access to FinLens, and separately approves sharing insights with your app specifically.

Hosted flow · PKCE · never a WebView
2

FinLens parses server-side

Sender-verified financial emails are ingested and parsed inside an isolated, audited boundary: bank & card statements, password-locked PDFs, eCAS portfolio files, insurance policies, mandates, receipts — normalized into one canonical financial graph per user.

DKIM-authenticated senders only
3

Your app gets insights

The optimisation engine finds where the user is losing money and returns typed Insight objects — with evidence, severity, and yearly impact — via REST APIs, webhooks, and drop-in UI components. Every insight is explainable: "because 3 charges of ₹590…".

Typed objects · webhooks · UI kit
The insight catalog

Money leaks your product can now find

A growing catalog of deterministic, explainable detectors — each one renders to the end user with evidence and rupee impact. Here's a sample of what ships in v1.

Card interest & late fees

Revolving interest and late fees quietly compounding across the user's cards, annualized so the real cost lands.

cc.interest_paid

Zombie subscriptions

Recurring charges with no usage signal — or duplicate services in the same class, like two streaming plans.

sub.zombie

Subscription price creep

The same merchant charging steadily more over time — surfaced the moment the pattern forms.

sub.price_creep

Bank account charges

Minimum-balance penalties, SMS and service fees across every account the user holds — totalled and traced.

bank.charges

Orphan mandates

Active auto-debit mandates with no matching service emails — money leaving for services the user may have forgotten.

mandate.orphan

Insurance overlap & lapse risk

Duplicate or overlapping covers, premium outliers, and premiums about to lapse with grace-period countdowns.

ins.overlap · ins.lapse_risk

Missed refunds

A refund promised by email that never posted to any statement — pure fact, and a crowd favourite.

cash.refund_missed

Fund plan cost drag

Expense-ratio drag on mutual-fund folios computed from the user's own eCAS — the math shown, framed educationally.

mf.regular_vs_direct

Forex & conversion markups

Cross-currency and dynamic-conversion markups summed across the user's card spend abroad and online.

cc.forex_markup
Built for developers

Integrate in a day, not a quarter

The SDK is deliberately thin: open the hosted consent flow safely, stream sync progress, read insights. All intelligence stays server-side — so SDK releases are rare, small, and low-risk.

Every platform, one mental model

Web, React Native, Flutter, and a Node backend SDK with HMAC signing built in. Identical API names across platforms — docs translate 1:1. REST for everything else.

Zero secrets in your clients

SDKs never see mailbox tokens and store nothing durable. Frontends handle a one-shot public token; your backend holds a revocable, partner-scoped grant. That's it.

A sandbox that behaves like production

A synthetic mailbox corpus — statements, eCAS files, premium notices, receipts — replays through the real pipeline. Integrate end-to-end, including webhooks and deletion, before touching a single real mailbox.

Live progress, not spinners

A sync event stream lets your UI say "Reading statements… found 3 leaks so far" while backfill runs. First insights typically land within five minutes of consent.

import { FinLens } from "@finlens/web";

const fl = FinLens.init({ env: "sandbox" });

// 1 · Open the hosted consent flow
const handler = fl.createConnect({
  connectToken,                      // minted by your backend
  onSuccess: ({ publicToken }) => sendToBackend(publicToken),
  onExit:    ({ code }) => showRetry(code),
  onEvent:   (e) => track(e),       // OPENED, CONSENT_SHOWN, LINKED…
});
handler.open();

// 2 · Read insights + stream sync progress
const client = fl.client({ clientToken });
const { insights } = await client.insights.list({ state: "new" });
client.sync.subscribe((s) => renderProgress(s));
import { FinLensAdmin } from "@finlens/node";

const fl = new FinLensAdmin({ apiKeyId, apiSecret }); // HMAC built in

// 1 · Mint a connect token for your frontend
const { connectToken } = await fl.connect.createToken({
  endUserRef: "user_8231",
  products: ["insights"],
});

// 2 · Exchange after the user consents
const { grantId, personaId } = await fl.connect.exchange({ publicToken });

// 3 · Short-lived, read-only token for your frontend
const { clientToken } = await fl.personas.clientToken(personaId);
import { FinLens } from "@finlens/react-native";

const fl = FinLens.init({ env: "sandbox" });

// Chrome Custom Tabs / ASWebAuthenticationSession —
// never a WebView, returns via verified app links
const handler = fl.createConnect({
  connectToken,
  onSuccess: ({ publicToken }) => api.link(publicToken),
  onExit:    ({ code }) => {},
});
handler.open();

const { insights } = await fl.client({ clientToken })
  .insights.list({ state: "new" });
final fl = FinLens.init(env: Env.sandbox);

// Same names as the TS SDKs — docs translate 1:1
final handler = fl.createConnect(
  connectToken: connectToken,
  onSuccess: (r) => api.link(r.publicToken),
  onExit: (e) => {},
);
await handler.open();

final insights = await fl
    .client(clientToken)
    .insights
    .list(state: "new");
// Signed, retried, replayable — verify in one line
app.post("/finlens/webhooks", (req, res) => {
  const events = fl.webhooks.verify(req.headers, req.rawBody);

  for (const e of events) {
    switch (e.type) {
      case "insight.created":       // new money leak found
      case "grant.requires_relink": // user revoked at provider
      case "consent.revoked":       // user revoked your app
        handle(e);
    }
  }
  res.sendStatus(200);
});
Security & compliance

Built to pass audits, not just reviews

FinLens carries the mailbox-platform verification and annual independent security assessment (CASA) once, so every integrating app inherits a compliant capability without touching restricted data.

Isolated vault & boundary

Mailbox tokens live in an encrypted vault (AES-256-GCM envelope encryption, managed KMS, rotated keys) inside a network-isolated boundary. Raw email is transient — parsed and reaped within 24 hours.

Annual independent assessment

The platform is designed to OWASP ASVS L2 and undergoes Google's CASA security assessment annually as a restricted-scope application. Your app never enters that audit scope.

DPDP-ready by construction

Immutable consent ledger, one-click withdrawal parity, verified deletion with per-store receipts, breach runbooks, and data-residency in Mumbai (asia-south1) for India-first products.

Phishing can't poison the graph

Only DKIM/SPF-authenticated senders from a curated institution registry are parsed. A spoofed "bank email" in the mailbox never becomes a verified insight.

Hash-chained audit trail

Every access, egress, and deletion is written to an append-only, hash-chained audit log. Human access to the boundary requires just-in-time approval by a second person, fully recorded.

Blast-radius controls per app

Scoped keys, per-app rate classes, anomaly detection, response watermarking, and a kill switch per integration — a compromised partner cannot become a platform incident.

Build vs. integrate

What you'd be signing up to build yourself

Reading customer email is a regulated, audited, quota-bound, parser-heavy capability. FinLens exists so you only build the part your users see.

CapabilityBuilding in-houseWith FinLens
Restricted-scope verification ~6-week review, brand assets, demo videos, scope justification — repeated on every scope change Inherited. FinLens holds the verified app; your scopes never change
Annual security assessment (CASA) Yearly independent audit of every system touching mailbox data, at your cost Inherited. Your app stays outside the audit boundary
Parser fleet Per-institution templates: statements, locked PDFs, eCAS, policies — breaking silently on every redesign Maintained for you, with canary alerts and versioned replay on fixes
Locked-PDF handling PAN/DOB password flows, secret custody, OCR for scanned and regional-language documents Built in — vaulted or ephemeral password modes, user-chosen
Quota engineering Per-user and project-wide API quotas, push-notification renewal, backfill pacing Managed — first insights in minutes, deep history in the background
Consent & deletion machinery Consent ledger, withdrawal parity, verified erasure, breach notification clocks Platform-native, with receipts your compliance team can hand to auditors
Time to first user insight Quarters About a day of integration — sandbox keys to production path included
FAQ

Questions teams ask before integrating

What exactly does my app receive?
Typed Insight objects — key, severity, yearly money impact, confidence, lifecycle state — plus display-safe evidence summaries ("3 late fees on HDFC ****4523 totalling ₹1,770") and aggregate meters like total savings found. Apps with an approved need can request normalized financial objects (accounts, transactions, holdings) under an enhanced review tier and explicit user consent language. Raw email content is never available on any tier.
Do we ever touch mailbox credentials or tokens?
No. OAuth happens on FinLens's hosted, verified domain in the system browser. Tokens are stored only in FinLens's encrypted vault. Your frontend relays a one-shot public token; your backend holds a revocable FinLens grant. There is nothing credential-shaped for you to store, rotate, or leak.
How is user consent captured and proven?
Twice, independently: once for mailbox access (Layer 1) and once for sharing insights with your app specifically (Layer 2). Every grant stores the exact consent text shown (content-addressed), version, language, and timestamp in an append-only ledger. Users can revoke either layer any time from a self-serve portal — revoking your app doesn't force them to disconnect their mailbox.
What happens when a user revokes access?
You get a consent.revoked webhook and egress for that user stops in under a minute. If the user revokes mailbox access at the provider, you get grant.requires_relink and the SDK ships a re-link flow. Full deletion is orchestrated across every store with per-store receipts — typically complete within 24–72 hours.
Can users see and control what's read?
Yes. Before consenting they see exactly which senders are read (the curated financial-institution registry — banks, card issuers, insurers, fund houses, depositories) and that personal mail is never fetched. Afterwards, the FinLens portal shows every connected app, every consent, a full data export, and a delete-everything button.
Which email providers are supported?
Gmail at launch — it's where the vast majority of Indian retail financial email lives. The ingestion layer is provider-abstracted; document upload (eCAS/CAS files) and additional providers are on the roadmap. Your integration doesn't change when providers are added.
Is this financial advice?
No. Insights are observational and educational — facts about the user's own money ("you paid ₹1,770 in late fees") and generic explanations of the math. FinLens does not recommend specific financial products, name alternatives, or route users to providers, and every insight's copy is compliance-reviewed against SEBI/IRDAI/RBI advice lines.
How do we get started?
Request sandbox access below. You'll get API keys, the synthetic mailbox corpus, and full docs. Most teams have the end-to-end flow — consent, sync progress, insight feed, webhooks — running in a day. Production access follows a short partner review covering your user-facing feature and consent presentation.

Give your users X-ray vision into their own money.

Sandbox keys, a realistic synthetic mailbox, and docs that get you to your first insight today — no mailbox provider setup, no compliance project.