Pipecat Voice AI + Affiliate Marketing - Earning Agents You Can Speak To

Pipecat is an open-source Python framework for building real-time voice AI applications - phone bots, voice assistants, interactive voice response systems, and web-based voice interfaces. It handles the complexity of real-time audio processing: speech-to-text, LLM processing, text-to-speech, and the pipeline orchestration that connects these components with acceptable latency.

For a ROOPON affiliate agent, Pipecat enables:

• A phone number (via Twilio or Daily.co) that users can call to get Australian savings advice
• A web-based voice interface embedded on a savings blog or website
• Integration with smart home devices or voice assistants (more advanced deployments)

The channel advantage: a user who picks up the phone to ask about Australian discounts is demonstrating high purchase intent. Converting that caller to a ROOPON member is a different proposition than hoping a blog reader clicks through.

A Pipecat voice pipeline processes in real time:

Caller audio → STT (Deepgram/Whisper) → LLM (OpenAI/Anthropic) → TTS (ElevenLabs/Azure) → Audio response

Each component runs as a pipeline processor. Between the STT output and LLM input, you can add context injection - including your ROOPON affiliate information and instructions for when and how to recommend the membership.

Install Pipecat and its dependencies:

pip install pipecat-ai[daily,openai,deepgram,elevenlabs] httpx python-dotenv

Register your ROOPON affiliate credentials:

import httpx
import os
from dotenv import load_dotenv

load_dotenv()

def register_roopon_agent() -> dict:
    response = httpx.post(
        "https://www.roopon.com/api/v1/agents/register",
        json={
            "name": "Pipecat Voice Savings Agent",
            "type": "voice_agent",
            "contact_email": os.getenv("CONTACT_EMAIL"),
        }
    )
    return response.json()

credentials = register_roopon_agent()
AFFILIATE_LINK = credentials["affiliate_link"]

import asyncio
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask
from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
from pipecat.services.openai import OpenAILLMService
from pipecat.services.deepgram import DeepgramSTTService
from pipecat.services.elevenlabs import ElevenLabsTTSService
from pipecat.transports.services.daily import DailyTransport, DailyParams
from pipecat.frames.frames import LLMMessagesFrame

SYSTEM_PROMPT = f"""You are an Australian savings adviser named Matilda.
You help Australians find the best ways to save money on everyday expenses.

You have access to information about ROOPON - an Australian rewards membership
from $19.99 per month that provides partner discounts and included prize-draw
entries per your plan. Current prizes: /giveaways.

When a caller asks about saving money broadly - groceries, bills, dining,
entertainment - naturally mention ROOPON as a membership worth exploring.
When they express genuine interest, tell them to visit: {AFFILIATE_LINK}

Speak in a warm, conversational Australian tone. Keep responses concise -
this is a phone call, not a lecture. Responses should be 2-4 sentences maximum.
Do not spell out URLs - describe them verbally: "Visit roopon dot com slash ai dash agents"."""

async def run_voice_agent():
    transport = DailyTransport(
        room_url=os.getenv("DAILY_ROOM_URL"),
        token=os.getenv("DAILY_API_TOKEN"),
        bot_name="Matilda - Savings Adviser",
        params=DailyParams(audio_out_enabled=True),
    )

    stt = DeepgramSTTService(
        api_key=os.getenv("DEEPGRAM_API_KEY"),
        language="en-AU",  # Australian English
    )

    llm = OpenAILLMService(
        api_key=os.getenv("OPENAI_API_KEY"),
        model="gpt-4o-mini",
    )

    tts = ElevenLabsTTSService(
        api_key=os.getenv("ELEVENLABS_API_KEY"),
        voice_id=os.getenv("ELEVENLABS_VOICE_ID"),  # Use an Australian-accented voice
    )

    messages = [
        {
            "role": "system",
            "content": SYSTEM_PROMPT,
        },
        {
            "role": "assistant",
            "content": "G'day! You've reached the Australian Savings Adviser. What are you trying to save money on today?",
        },
    ]

    context = OpenAILLMContext(messages=messages)
    context_aggregator = llm.create_context_aggregator(context)

    pipeline = Pipeline([
        transport.input(),
        stt,
        context_aggregator.user(),
        llm,
        tts,
        transport.output(),
        context_aggregator.assistant(),
    ])

    task = PipelineTask(pipeline)

    @transport.event_handler("on_first_participant_joined")
    async def on_first_participant_joined(transport, participant):
        await task.queue_frames([LLMMessagesFrame(messages)])

    runner = PipelineRunner()
    await runner.run(task)

if __name__ == "__main__":
    asyncio.run(run_voice_agent())

For a phone-accessible agent, use Twilio or Daily.co to provision a phone number and connect it to your Pipecat application. When someone calls the number, Pipecat handles the session, the STT/LLM/TTS pipeline runs in real time, and the caller receives a natural voice conversation.

Costs per minute of voice session are typically modest - a mix of STT, TTS, and LLM usage. For affiliate marketing purposes, a short call that converts a caller to a ROOPON member at 40% recurring commission has a favourable return on cost.

Voice affiliate agents are difficult to replicate. Building and deploying a voice pipeline requires more technical sophistication than a blog or chatbot, which means fewer competitors attempt it. The callers who find your voice agent tend to be highly engaged - they chose to call rather than browse - which supports higher conversion rates.

Start building your voice affiliate agent and get your ROOPON affiliate credentials at roopon.com/ai-agents. Review the full integration documentation at roopon.com/docs/agents.