fin-infra

Financial Infrastructure

Complete billing infrastructure for payments, subscriptions, and invoicing.

fin-infra

Financial data infrastructure for fintech apps

PyPI Python 3.11+ License: MIT Downloads

Banking, investments, market data, credit scores, and financial calculations in one toolkit.

Documentation · Examples · PyPI

Why fin-infra?

Building a fintech app means integrating Plaid, pulling market data, calculating portfolio returns, categorizing transactions... and doing it all securely.

fin-infra gives you production-ready financial infrastructure:

python
from fin_infra.banking import easy_banking
from fin_infra.markets import easy_market

# Connect to banks via Plaid
banking = easy_banking()
accounts = await banking.get_accounts(access_token)
transactions = await banking.get_transactions(account_id)

# Get market data
market = easy_market()
quote = market.quote("AAPL")

Quick Install

bash
pip install fin-infra

What's Included

FeatureWhat You GetOne-liner
BankingPlaid/Teller integration, accounts, transactionseasy_banking()
InvestmentsHoldings, portfolio data, real P/L with cost basiseasy_investments()
Market DataStocks, crypto, forex quotes and historyeasy_market()
CreditCredit scores and monitoringeasy_credit()
AnalyticsCash flow, savings rate, spending insightsBuilt-in
BudgetsMulti-type budget tracking with templatesScaffold included
GoalsFinancial goal tracking with milestonesScaffold included
CashflowsNPV, IRR, loan amortization calculationsnpv(), irr()

30-Second Examples

Connect Bank Accounts

python
from fin_infra.banking import easy_banking

banking = easy_banking(provider="plaid")

# Get linked accounts
accounts = await banking.get_accounts(access_token)
for acc in accounts:
    print(f"{acc.name}: ${acc.balance}")

# Get transactions
transactions = await banking.get_transactions(account_id)

Portfolio Holdings with Real P/L

python
from fin_infra.investments import easy_investments

investments = easy_investments(provider="plaid")

# Get holdings with cost basis
holdings = await investments.get_holdings(access_token)
for h in holdings:
    print(f"{h.symbol}: {h.quantity} shares, P/L: ${h.unrealized_gain}")

# Asset allocation
allocation = await investments.get_allocation(access_token)
print(allocation)  # {"stocks": 60, "bonds": 30, "cash": 10}

Real-Time Market Data

python
from fin_infra.markets import easy_market, easy_crypto

# Stock quotes
market = easy_market()
quote = market.quote("AAPL")
print(f"AAPL: ${quote.price} ({quote.change_percent}%)")

# Crypto
crypto = easy_crypto()
btc = crypto.ticker("BTC/USDT")
print(f"BTC: ${btc.price}")

Credit Scores

python
from fin_infra.credit import easy_credit

credit = easy_credit()
score = await credit.get_credit_score(user_id)
print(f"Credit Score: {score.value} ({score.rating})")

Financial Calculations

python
from fin_infra.cashflows import npv, irr, loan_payment

# Net Present Value
cashflows = [-100000, 30000, 30000, 30000, 30000]
value = npv(rate=0.08, cashflows=cashflows)
print(f"NPV: ${value:,.2f}")

# Internal Rate of Return
rate = irr(cashflows)
print(f"IRR: {rate:.2%}")

# Loan payments
monthly = loan_payment(principal=250000, rate=0.065, years=30)
print(f"Monthly payment: ${monthly:,.2f}")

FastAPI Integration

Use with svc-infra for a complete backend:

python
from fastapi import FastAPI
from svc_infra.api.fastapi.ease import easy_service_app
from fin_infra.banking import add_banking
from fin_infra.investments import add_investments
from fin_infra.markets import add_market_data

# Create app with svc-infra (auth, database, etc.)
app = easy_service_app(name="FinanceAPI", release="1.0.0")

# Add financial capabilities
add_banking(app, provider="plaid")
add_investments(app, provider="plaid")
add_market_data(app, provider="alphavantage")

# Automatic endpoints:
# GET  /banking/accounts
# GET  /banking/transactions
# GET  /investments/holdings
# GET  /investments/allocation
# GET  /market/quote/{symbol}

Supported Providers

CategoryProviders
BankingPlaid, Teller
InvestmentsPlaid
Market DataAlpha Vantage, Yahoo Finance
CryptoCoinGecko, Binance
CreditExperian

Scaffold Models

Generate production-ready models for your app:

bash
# Generate budget models
fin-infra scaffold budgets --dest-dir app/models/ --include-tenant

# Generate goal tracking
fin-infra scaffold goals --dest-dir app/models/

# Generate net worth snapshots
fin-infra scaffold net-worth --dest-dir app/models/

What you get:

  • SQLAlchemy models with proper indexes
  • Pydantic schemas (Create, Read, Update)
  • Repository pattern with async CRUD
  • Type hints throughout

Wire CRUD in one call:

python
from svc_infra.api.fastapi.db.sql import add_sql_resources, SqlResource
from app.models.budgets import Budget

add_sql_resources(app, [
    SqlResource(
        model=Budget,
        prefix="/budgets",
        search_fields=["name", "description"],
    )
])
# Creates: POST, GET, PATCH, DELETE /budgets/*

Configuration

bash
# Banking (Plaid)
PLAID_CLIENT_ID=your_client_id
PLAID_SECRET=your_secret
PLAID_ENV=sandbox  # or development, production

# Market Data
ALPHAVANTAGE_API_KEY=your_api_key

# Credit (Experian)
EXPERIAN_CLIENT_ID=your_client_id
EXPERIAN_CLIENT_SECRET=your_secret

Documentation

ModuleDescription
Data Integration
BankingAccount aggregation, transactions
InvestmentsHoldings, portfolio, P/L
Market DataStocks, crypto, forex
CreditCredit scores and reports
Analytics
AnalyticsCash flow, savings rate, insights
Net WorthNet worth tracking
CashflowsNPV, IRR, loan calculations
Features
BudgetsBudget management
GoalsFinancial goal tracking
InsightsAI-powered insights
CategorizationTransaction categorization
Infrastructure
PersistenceScaffold workflow
API GuideBuilding fintech APIs
ComplianceGLBA, FCRA, PCI-DSS

Architecture

fin-infra is the financial data layer. Use with svc-infra for backend infrastructure:

code
Your App
    |
    +-- fin-infra (financial data)
    |       Banking, investments, market data, credit
    |
    +-- svc-infra (backend infrastructure)
            Auth, database, API framework, jobs, billing

This separation keeps financial logic clean and portable.

Running Examples

bash
git clone https://github.com/nfraxio/fin-infra.git
cd fin-infra
poetry install

# Market data (no auth needed)
poetry run python -c "
from fin_infra.markets import easy_market
market = easy_market()
print(market.quote('AAPL'))
"

# Run all tests
poetry run pytest -q

fin-infra is part of the nfrax infrastructure suite:

PackagePurpose
fin-infraFinancial infrastructure (banking, portfolio, insights)
svc-infraBackend infrastructure (auth, billing, jobs, webhooks)
ai-infraAI/LLM infrastructure (agents, tools, RAG, MCP)

License

MIT License - use it for anything.