Most internet services are also financial services. From recurring subscription payments, investment banking, issuing transfers and payouts to bank accounts, consumer retail, forex exchanges, bitcoin, payroll services; take your pick, there is plenty of opportunity to work with finance in tech.

Building these services properly and securely should not be a challenge. No one should end up with something like $100.000000000000000034 showing up on their bank statement.

In this post, I’m going to show you how to build a minimal financial service with the use of python, Babel.numbers, FastAPI, and Rates API.

To follow this post as written, using python 3.7+ is suggested.


To illustrate why it’s never a good idea to use float point arithmetic for working with financial data in python, let’s look at a simple example.

>>> float('0.1') + float('0.2')
0.30000000000000004

No bueno.

On paper, we’d say that 0.1 + 0.2 = 0.3. So now what? How do we get 0.3?!

>>> from decimal import Decimal
>>> r = Decimal('0.1') + Decimal('0.2')
Decimal('0.3')

Voila! We’ll get to formatting the figures later.

Let’s start by modeling out our system and its features.

Create the following files in a directory so that you have a project structure that looks like the following tree:

.
├── main.py
├── requirements.txt
└── schemas.py

Let’s add everything we’ll need to our requirements.txt

Babel==2.8.0
fastapi==0.47.1
pydantic==1.5.1
requests==2.22.0
uvicorn==0.11.2

Let’s start writing main.py which will serve as our main router and point of function for this example. For larger apps, you should use fastapi’s APIRouter module for defining your routes and a neat application structure for structuring the actions that take place in each route. Not to mention a database connection, I’m saving that for a later post.

from fastapi import FastAPI

from schemas import Payment

api = FastAPI()

@api.get('/health')
def health():
    return


@api.post('/payment', response_model=Payment, tags=['payment'])
def create_payment(payment: Payment):
    return

Nice, nothing fancy here. We’re just going to be able to create a payment and see what was returned. It looks like we’ve defined some pydantic schemas in our main.py so let’s write those.

Open up your schemas.py and drop this in.

from decimal import Decimal
from typing import Optional

import babel.numbers as bn
from pydantic import UUID4, BaseModel, validator

CURRENCIES = bn.list_currencies()
CURRENCY_VALUE_ERROR = ValueError(
    "Invalid currency code submitted. "
    f"Value must be one of the following {', '.join(CURRENCIES)}.")


class Payment(BaseModel):
    message: str
    sender_id: UUID4
    sender_currency: str
    sender_amount: Decimal
    sender_amount_formatted: Optional[str]
    receiver_id: UUID4
    receiver_currency: str
    receiver_amount_formatted: Optional[str]
    receiver_amount: Optional[Decimal]

    @validator('sender_amount')
    def positive_sender_amount(cls: BaseModel, v: Decimal) -> Decimal:
        if v <= 0:
            raise ValueError('Amount must be a positive number.')
        return v

    @validator('receiver_amount')
    def positive_receiver_amount(cls: BaseModel, v: Decimal) -> Decimal:
        if v and v <= 0:
            raise ValueError('Amount must be a positive number.')
        return v

    @validator('receiver_currency')
    def valid_receiver_currency(cls: BaseModel, v: str) -> str:
        if v not in CURRENCIES:
            raise CURRENCY_VALUE_ERROR
        return v

    @validator('sender_currency')
    def valid_sender_currency(cls: BaseModel, v: str) -> str:
        if v not in CURRENCIES:
            raise CURRENCY_VALUE_ERROR
        return v

Simple enough!

Awesome! With our schema written, we can build our currency converter in main.py.

from decimal import Decimal, getcontext

import babel.numbers as bn
import requests
from fastapi import FastAPI

from schemas import Payment

api = FastAPI()


def get_rate(sender_currency: str, receiver_currency: str) -> str:
    result = requests.get(
        "https://api.ratesapi.io/api/latest?"
        f"base={sender_currency}&symbols={receiver_currency}")
    return str(result.json().get('rates').get(receiver_currency))


def calculate_receiver_amount(payment: Payment) -> Decimal:
    rate = get_rate(payment.sender_currency, payment.receiver_currency)
    # we can set and alter decimal precision setting however we want
    # https://docs.python.org/3.7/library/decimal.html#module-decimal
    getcontext().prec = 4
    return Decimal(rate) * Decimal(payment.sender_amount)


def payment_with_conversion(payment: Payment) -> Payment:
    payment.receiver_amount = calculate_receiver_amount(payment)
    return payment


def formatted_payment(payment: Payment) -> Payment:
    payment.sender_amount_formatted = bn.format_currency(
        payment.sender_amount, payment.sender_currency)
    payment.receiver_amount_formatted = bn.format_currency(
        payment.receiver_amount, payment.receiver_currency)
    return payment


@api.get('/health')
def health():
    return


@api.post('/payment', response_model=Payment, tags=['payment'])
def create_payment(payment: Payment):
    return formatted_payment(payment_with_conversion(payment))

Let’s give it a shot! Run the following commands to install requirements and start-up your service.

pip3 install -r requirements.txt
uvicorn main:api --reload

You should see the following.

$ uvicorn main:api --reload
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [55640]
INFO:     Started server process [55651]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

And now you can kick off a sample request with the following command. You may need to install jq.

$ curl -s -X POST "localhost:8000/payment" -d '{
  "sender_id": "12892e99-b4c6-4f6b-b433-01996c1d8ec0",
  "receiver_id": "c0626613-60d5-4d7a-9f12-8865febcfa9f",
  "sender_amount": "20",
  "sender_currency": "USD",
  "receiver_currency": "EUR",
  "message": "Cheers 🍻"
}' | jq
{
  "message": "Cheers 🍻",
  "sender_id": "12892e99-b4c6-4f6b-b433-01996c1d8ec0",
  "sender_currency": "USD",
  "sender_amount": 20,
  "sender_amount_formatted": "$20.00",
  "receiver_id": "c0626613-60d5-4d7a-9f12-8865febcfa9f",
  "receiver_currency": "EUR",
  "receiver_amount_formatted": "€18.28",
  "receiver_amount": 18.28
}

Awesome! We have a simple service that does basic currency conversions. For this to be production ready, you’d want to implement a higher fidelity currency rate exchange service (i.e. something that gives real-time exchange rates), gunicorn for running workers and threads, a datastore for managing transactions and other payments, and some actual infrastructure to run it all.

Want to issue payments and connect bank accounts? Lots of the details are handled for you by stripe – would totally suggest checking them out. For other cool finance software, there’s also a bunch of stuff on github you should check out.

I’ll be covering more on that eventually but hope this covers the basis for creating a stateless API that works with financial data reasonably well.