Account and loan records inside Maroon Financial's mobile portal

Approximately 7,000 members of the University of Chicago community — staff, students, and alumni, per a Tyfone press release — hold checking, savings, and loan accounts at Maroon Financial Credit Union in Hyde Park, Chicago. Their transaction histories, cleared-check scans, bill-payment records, and loan details all sit behind the credit union's Tyfone nFinia–powered mobile app and online banking portal.

The integration route runs through the nFinia session layer: a single authenticated channel that covers every account type, including the credit card data that was previously siloed on a separate website. We map that session, build a working client, and hand over the source code.

What the Tyfone portal holds

Maroon Financial's nFinia portal consolidates data that was formerly split across separate online and mobile systems. The table below reflects what the mobile app exposes to an authenticated member, as described on the credit union's digital banking page.

Routes to the member data

1. Authorized interface integration via the nFinia session

The primary route. We capture and analyze the traffic between the mobile app and the nFinia backend, map the session-establishment flow (MFA challenge, token issuance, renewal), and build a client that replays those calls programmatically. This covers all eight data domains above in a single authenticated channel. Access is arranged with you during onboarding — typically using the member's own consenting credentials in a sandboxed run — and the build proceeds from there.

2. User-consented credential access

Where the member directly authorizes their login for a third-party service. The integration authenticates as the member, walks the MFA flow, and queries the portal on a scheduled or on-demand basis. This route is operationally similar to route 1 but framed around ongoing delegated access rather than a one-time protocol map.

3. Native export as a baseline

Maroon Financial's online banking supports CSV, OFX, QBO, and QFX export of transaction history, per the digital banking portal. Native export is useful for batch reconciliation and as a cross-check against the live-session data during testing, but it does not cover check images, loan details, or real-time balances.

For this credit union, interface integration through the nFinia session (route 1) gives the widest data coverage and the cleanest automation path. Native export stays in the build as a verification layer and a fallback for historical batch pulls.

Session flow and data endpoints

The snippet below reflects the shape of a working nFinia integration. Exact hostnames and endpoint paths are confirmed during the build; the structure and field names shown here are illustrative.

# Illustrative — exact endpoints confirmed during the build
import httpx

NFINIA_BASE = "https://<confirmed-during-build>/nfinia/api/v1"

async def authenticate(user_id: str, password: str, mfa_token: str) -> str:
    payload = {
        "userId": user_id,
        "credential": password,
        "mfaResponse": mfa_token,
        "platform": "android",
        "appVersion": "current"
    }
    r = await httpx.AsyncClient().post(
        f"{NFINIA_BASE}/auth/session", json=payload
    )
    r.raise_for_status()
    return r.json()["sessionToken"]

async def get_accounts(token: str) -> list:
    r = await httpx.AsyncClient().get(
        f"{NFINIA_BASE}/accounts",
        headers={"Authorization": f"Bearer {token}"}
    )
    r.raise_for_status()
    return r.json()["accounts"]
    # Each account: id, type (SHARE_SAVINGS | CHECKING | LOAN | CREDIT_CARD),
    #   name, availableBalance, currentBalance, maskedNumber

async def get_transactions(token: str, acct_id: str, from_date: str) -> list:
    r = await httpx.AsyncClient().get(
        f"{NFINIA_BASE}/accounts/{acct_id}/transactions",
        params={"fromDate": from_date},
        headers={"Authorization": f"Bearer {token}"}
    )
    r.raise_for_status()
    return r.json()["transactions"]
    # Each: date, description, amount, runningBalance, checkImageUrl (if check)

Source code and documentation package

The delivered package for Maroon Financial includes:

• An OpenAPI / Swagger specification covering every queryable nFinia endpoint for this credit union — accounts, transactions, check images, loans, card data, and bill-pay records.
• A protocol and auth-flow report documenting the session lifecycle: MFA challenge type (as deployed by Maroon Financial's nFinia instance), token format, expiry window, and renewal mechanism.
• Runnable source code (Python or Node.js, your choice) that authenticates, queries each account type, and returns normalized JSON. The check-image module downloads front/back scans as files.
• An automated test suite validating each endpoint against live or recorded responses, including error-path handling for expired sessions and MFA re-prompts.
• Interface documentation: field mappings, rate-limit observations, and notes on how Maroon Financial's nFinia instance differs from generic nFinia deployments (if it does).
• Compliance and data-retention guidance specific to this credit union's regulatory context (NCUA / IDFPR).

When you would use this integration

Three scenarios that come up with a credit union of this profile:

Accounting sync for a university department. A UChicago department or lab that banks with Maroon Financial needs nightly transaction pulls into its accounting system. The integration feeds normalized transaction records and check images directly, avoiding manual CSV downloads and the formatting mismatches that come with them.

Loan-portfolio visibility for a member. A member with multiple Maroon Financial loan products — auto loan, personal, line of credit — wants a consolidated view with amortization schedules and payment history in one place. The integration queries each loan account and normalizes the payment timeline.

Multi-institution aggregation. A fintech aggregating credit-union data across several small institutions needs a Maroon Financial connector. The nFinia session integration slots into the aggregator's pipeline alongside connectors for other credit unions, producing a uniform data schema regardless of the underlying core processor.

Member consent and Illinois regulatory standing

Maroon Financial Credit Union is a state-chartered, federally insured institution. Its state regulator is the Illinois Department of Financial and Professional Regulation (IDFPR); deposit insurance is through the NCUA's National Credit Union Share Insurance Fund. The credit union's charter number, per ncuso.org, is 62497.

The dependable basis for this integration is the member's own authorization. The member consents to data access, specifying which account types and what date range; that consent is logged, time-bounded, and revocable. Data minimization applies: the integration queries only what the member has authorized and retains nothing beyond the agreed scope.

At the federal level, the CFPB's Personal Financial Data Rights rule (12 CFR Part 1033) would formalize structured data-sharing obligations for institutions like Maroon Financial, but enforcement of that rule is currently enjoined and the rule is under agency reconsideration, per a Cozen O'Connor analysis from 2026. The practical effect today: member consent, not a federal mandate, is the mechanism. If the rule is finalized in a form that applies to credit unions of this asset size, the integration would shift to the mandated channel; the delivered source code is designed so that migration is a configuration change, not a rebuild.

Engineering notes for this build

Maroon Financial migrated from separate online and mobile vendors — with different credentials for each — to Tyfone's unified nFinia platform, per a 2021 press release. We design the integration against the nFinia session layer but verify during the build whether any legacy endpoints from the prior mobile vendor remain active. If they do, the delivered client covers both.

The credit card account data, which was previously on a separate website requiring its own login, is now surfaced through the same nFinia session. We confirm during onboarding whether the consolidated view includes full statement-level detail for the card or only summary balances, and scope the card-data module accordingly.

Maroon Financial's digital banking uses a tiered security model with multifactor authentication, per their site. The build maps the specific MFA method — SMS, email, or authenticator-app — and the delivered client handles the challenge programmatically where the method permits, or prompts for manual entry where it does not.

Sync cadence and data reliability

Transaction data in the nFinia portal typically reflects core-processor postings, so the practical refresh window is tied to the core's batch cycle. For a credit union of Maroon Financial's size, that is usually same-day for ACH and real-time for on-us transactions, but we confirm the exact cadence during the build.

The delivered client supports both scheduled polling (e.g., hourly or nightly) and on-demand queries. Session tokens have a finite lifetime; the client handles renewal transparently so that long-running sync jobs do not break mid-pull. Check images are fetched only when a new check transaction appears, avoiding redundant downloads.

Pricing and next steps

For Maroon Financial, the core deliverable is a working client covering nFinia session authentication and all account-type queries — checking, savings, loans, card — plus the OpenAPI spec, test suite, and interface documentation described above. Source-code delivery starts at $300, paid after you have reviewed the working code and are satisfied. Alternatively, call our hosted endpoints on a pay-per-call basis with no upfront commitment, billed per request. Typical turnaround is 1–2 weeks from kickoff. Tell us the app name and what you need from the data; access, credentials, and compliance paperwork are handled as part of the engagement.

Similar university and community credit union apps

Maroon Financial sits in a category of small, campus-affiliated credit unions whose mobile apps hold similar account data. An integrator building connectors across this space would encounter these apps:

Credit Union 1 serves the University of Illinois Chicago community with mobile banking, Zelle, and mobile deposit; its data surfaces mirror Maroon Financial's core set. CAMPUS USA Credit Union, based in Gainesville, Florida, offers a full mobile banking suite for a university-adjacent membership and adds Zelle integration. UVA Community Credit Union provides bill pay, transfers, and mobile deposit for the University of Virginia community. University Credit Union (UCU) serves UCLA and other California university communities with a digital banking app covering checking, savings, and loans.

University of Michigan Credit Union (UMCU) operates a mobile app with check deposit and account management for campus members. Alive Credit Union and Best Financial Credit Union are similarly sized community institutions with comparable mobile-banking feature sets. evergreenDIRECT Credit Union serves its community with online and mobile banking, including remote deposit. U of I Community Credit Union covers the University of Illinois system with checking, savings, and loan products through its mobile app.

Each of these apps presents a similar integration profile: an authenticated portal on a platform like Tyfone, Alkami, or Q2, with account, transaction, and check-image data behind the session. A unified connector strategy across them produces a normalized schema regardless of the underlying vendor.

Where this mapping comes from

This brief is based on the Maroon Financial Credit Union mobile app listing (Google Play, package maroonfcu.mbanking), the credit union's digital banking page, a Tyfone press release on the nFinia migration, and the CFPB's reconsideration page for the Personal Financial Data Rights rule. The NCUA charter record was checked via ncuso.org.

OpenBanking Studio integration desk · mapping reviewed 2026-06-06

Integrator questions about Maroon Financial

Does the integration cover Maroon Financial's credit card data alongside checking and savings?

Yes. Maroon Financial previously hosted credit card accounts on a separate portal, but the Tyfone nFinia migration consolidated everything under one authenticated session. The integration pulls credit card balances, statement cycles, and transaction detail from the same session as checking and share-savings accounts.

Can check images be extracted as files rather than just line-item records?

The mobile app renders front and back images for deposited and cleared checks. The delivered source code captures these as individual image files keyed to the corresponding transaction record, so downstream systems can attach the scan to each item.

How does Tyfone's nFinia platform affect the build?

nFinia provides a unified session layer between the member-facing app and the core processor. This simplifies the integration because one session flow covers all account types. The protocol analysis targets the nFinia endpoints specifically, and the delivered client handles token renewal so the connection does not expire silently.

Maroon Financial Credit Union — app profile

Maroon Financial Credit Union has served the University of Chicago community since 1957, originally founded by faculty and administrative staff to provide credit at reasonable rates. Located in Hyde Park, Chicago, it offers personal checking and savings accounts, auto loans, personal loans, bill consolidation, home improvement loans, payday-loan alternatives, and credit cards. Members also have access to shared branching at credit unions nationwide.

The mobile app (Android: maroonfcu.mbanking; also on iOS) provides 24-hour account access: balance checks, transaction history, fund transfers, bill pay, remote check deposit, member-to-member and external money transfers, check image viewing, and branch/ATM lookup.