Monetize by framework
How to Monetize a FastAPI AI App
FastAPI is a high-performance async Python web framework, common backend for LLM APIs and streaming endpoints. Teams reach for it to build LLM API backends, SSE/streaming chat endpoints, and agent microservices. Those are exactly the always-on, conversational experiences where a subscription wall or a banner ad tends to feel out of place, which is where a contextual, in-conversation ad model fits better.
What building with FastAPI usually looks like
A typical FastAPI project centers on LLM API backends, SSE/streaming chat endpoints, and agent microservices. The interface is a conversation, and value is delivered turn by turn rather than behind a checkout.
That shape is great for users and hard for revenue: the moment you gate it behind a paywall, casual usage, the majority of traffic for most FastAPI apps, drops off before it ever converts.
Why subscriptions and display ads are awkward for this stack
Subscriptions force a paying decision before the user has felt the value, and they leave every non-paying session earning nothing. Display networks (banners, sidebars) were built for static pages, not for a streaming FastAPI response, they compete with the conversation for attention instead of belonging to it.
Monetzly takes the other path: relevant, clearly-marked ads are placed inside the assistant's response stream, so free users can stay free while the app still earns on every session.
How Monetzly integrates with FastAPI
There is no official Monetzly Python SDK — the package is Node-only. The supported path for a Python stack is the gRPC service the package ships as tps_alter.proto: generate Python stubs and open a ProcessStream bidi call (StartRequest, then a TokenRequest per LLM token, then StopRequest), reading back the ad-injected TokenResponses. Alternatively, run a tiny Node sidecar that uses the SDK and stream tokens to it. Either way, confirm the auth handshake for non-JS clients before publishing.
FastAPI runs on Python, and there is no official Monetzly Python SDK. Integration goes through the gRPC service that ships with the package (tps_alter.proto), or a small Node sidecar that uses the SDK. The auth handshake for a direct non-JS client still needs confirming before you publish.
Integration snippet
# 1) Generate stubs from the proto shipped in the SDK package:
# python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. tps_alter.proto
import grpc
import tps_alter_pb2 as pb
import tps_alter_pb2_grpc as rpc
async def inject(llm_tokens, prompt, session_id, api_key):
# TODO_VERIFY: how is the API key passed for a direct gRPC client?
# (metadata key name / channel credentials). Confirm with Monetzly.
creds = grpc.ssl_channel_credentials()
async with grpc.aio.secure_channel("your-server.com:443", creds) as ch:
stub = rpc.TPSAlterServiceStub(ch)
async def requests():
yield pb.StreamRequest(start=pb.StartRequest(
prompt=prompt, session_id=session_id, metadata={"api_key": api_key}))
async for tok in llm_tokens:
yield pb.StreamRequest(token=pb.TokenRequest(token=tok))
yield pb.StreamRequest(stop=pb.StopRequest(session_id=session_id))
async for resp in stub.ProcessStream(requests()):
if resp.HasField("token"):
yield resp.token.token # ad-injected token
# In a FastAPI route, feed your LLM's token generator into inject(...) and
# return the results with StreamingResponse.Frequently asked questions
Start monetizing in about 5 minutes
Wrap your existing LLM response stream with the Monetzly SDK and earn on every session, no paywall required.