Where do I put my Monetzly API key in a FastAPI app?

In an environment variable (e.g. MONETZLY_API_KEY) read at runtime — never hard-coded in source or shipped to the client.

Do I open a new connection per request in FastAPI?

Open a connection when a request begins and close it when the response stream finishes. The SDK manages reconnection internally.

How-to guide

How to Set Up the Monetzly SDK in FastAPI

This guide shows how to set up the Monetzly SDK in a FastAPI app, the goal being to get the SDK configured and connected before injecting any ads. It builds on the Monetzly gRPC service (no Python SDK exists for this stack), so the approach is specific to how FastAPI produces and streams responses.

Overview

Before you can monetize a FastAPI app, the Monetzly client needs configuring and connecting. This is a one-time setup: an API key, the ad-server address, and SSL settings, then a connection you open when a request starts and close when it ends.

Keep the API key in an environment variable, never in source. Use a non-SSL localhost address in development and your real ad-server host in production.

FastAPI apps are usually built for LLM API backends, SSE/streaming chat endpoints, and agent microservices, so set up the Monetzly SDK typically comes up while a user is mid-conversation, the moment where monetization has to be additive rather than disruptive.

How this works on 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.

Since FastAPI is a Python stack with no official SDK, this task runs through the shipped tps_alter.proto gRPC service (or a Node sidecar); the auth handshake for a direct client is still TODO_VERIFY.

Steps

Install the SDK (or, for a Python FastAPI stack, generate gRPC stubs from the shipped tps_alter.proto).
Create a config with your API key, server address, and SSL flag.
Open a connection at the start of a request and close it when the response finishes.

Integration snippet

TODO_VERIFY: FastAPI uses the gRPC proto path, confirm the auth handshake with Monetzly before relying on this in production.

# 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.