Run Reddit campaigns for multiple clients. One API key per account, full control.
Running Reddit marketing for 5 clients manually means 5 sets of logins, 5 separate planning sessions, 5 different posting schedules, and 5 weekly reports — all assembled by hand. At 2–4 hours per client per week, you hit a ceiling around 4–5 clients where the operations overhead makes it impossible to onboard more without hiring.
The data problem is equally painful: client reports are manually assembled from screenshots, spreadsheets, and platform dashboards. Every week, someone spends 90 minutes copying numbers into a Notion doc or Google Sheet. Clients want real-time visibility; you can only provide last week's static numbers.
The solution is treating each client's API key as the isolation boundary and building your own orchestration layer on top. Your backend loops over client configurations, runs discovery and scheduling for each independently, and generates automated reports — turning a 4-hour/client manual process into a 20-minute review.
The Reoogle API is designed for multi-tenant use from the ground up. Each client has their own account, their own API key, and their own data isolation. Your agency backend stores the keys in a secrets vault, iterates over clients on a schedule, and runs discovery, scheduling, and reporting for each independently. The result is a single interface you control that orchestrates multiple campaigns simultaneously — scaling to 10, 20, or 50 clients without proportional operations overhead.
Establish a secure key management pattern
Store each client's rog_live_ API key in a secrets vault (AWS Secrets Manager, Doppler, or even a simple encrypted Supabase table). Never hardcode keys or store them in environment variables where they're difficult to rotate. Build a getClientKey(clientId) abstraction that your entire backend uses — this makes key rotation trivial.
Build a client configuration schema
For each client, store: apiKey, category, postingFrequency (posts per week), contentTemplate (default title/body template), blockedSubreddits (ones that have removed posts), and targetMinMembers. This configuration drives all automated decisions and can be updated per client without code changes.
Run per-client subreddit discovery daily
For each client, call GET /subreddits/postable with their category and filter settings. Store the results in a per-client database table and refresh daily. This gives every client a tailored, always-current list of target communities — not a generic shared one.
Build a unified scheduling queue
Each morning, run a scheduling pass for all clients: fetch each client's pending content, select the day's target subreddits from their discovery list, and call POST /schedule for each post with staggered timing. Your scheduler should enforce per-client posting limits and minimum gaps between posts to the same subreddit.
Create a centralised monitoring dashboard
Poll GET /ai-posts for each client key every hour and write results to a shared database. Build a simple internal dashboard (Retool, or a custom Next.js app) that shows all clients' current post queue, live scores, and recent performance in one view — so your team can spot issues without logging into 5 accounts.
Automate weekly performance reports
Every Monday morning, run a report generation job: pull the past 7 days of post data for each client, calculate aggregate metrics (total posts, avg score, top performer, total comments), and format them into a branded email or Notion doc. Clients get data-driven reports automatically; you spend zero time on manual assembly.
Track usage against plan limits
Call GET /me/usage for each client key to check their API quota consumption. Build alerts that fire when a client is within 20% of their monthly limit — giving you time to upgrade their plan or throttle posting before they hit a wall. Usage visibility prevents surprise quota overages that interrupt campaigns mid-month.
Multi-client scheduler
interface Client {
name: string;
apiKey: string;
category: string;
postTemplate: { title: string; body: string };
}
async function runDailyCampaign(clients: Client[]) {
for (const client of clients) {
const headers = { Authorization: 0 , 1 : 2 };
3
const subsRes = await fetch(
4 ,
{ headers },
);
const subs = (await subsRes.json()).data as { name: string }[];
5
for (let i = 0; i < subs.length; i++) {
await fetch( 6 , {
method: 7 , headers,
body: JSON.stringify({
title: client.postTemplate.title,
body: client.postTemplate.body,
subreddit: subs[i].name,
scheduled_for: new Date(Date.now() + (i + 1) * 2 * 60 * 60_000).toISOString(),
}),
});
}
console.log( 8 );
}
}Weekly performance report
import requests
from datetime import datetime, timedelta
def weekly_report(api_key: str, client_name: str) -> dict:
headers = { 0 : f 1 }
res = requests.get(
2 ,
params={ 3 : 100},
headers=headers,
)
posts = res.json()[ 4 ]
cutoff = datetime.utcnow() - timedelta(days=7)
recent = [p for p in posts if p.get( 5 ) and
datetime.fromisoformat(p[ 6 ].rstrip( 7 )) > cutoff]
return {
8 : client_name,
9 : len(recent),
10 : sum(p[ 11 ] for p in recent) / max(len(recent), 1),
12 : sum(p[ 13 ] for p in recent),
14 : max(recent, key=lambda p: p[ 15 ], default=None),
}Using a single shared API key for multiple clients
Sharing keys means mixing analytics data, quota, and Reddit accounts across clients. Always give each client their own Reoogle account and key — data isolation is non-negotiable for an agency.
Running all clients on the same posting schedule
If 10 clients all post at 9am Monday, you create artificial activity spikes and make it obvious to observers that posts are automated. Stagger each client's start time by 30–90 minutes.
Not enforcing per-client subreddit blocklists
A subreddit that removed posts for Client A may be perfectly fine for Client B in a different category. Maintain blocklists per client, not globally, to avoid incorrectly skipping valid targets.
3.5 h
Time saved per client/week
Average operations time saved by automating discovery, scheduling, and reporting for one client.
15+
Max clients per operator
Number of active clients one person can manage using an automated API workflow vs 4–5 manually.
< 5 min
Report assembly time
Time to generate a complete weekly client report using automated data collection vs 90 min manually.
Can I white-label Reoogle for my clients?
Yes — the API is headless by design. You build the client-facing UI, reports, and dashboards using your own branding. Clients interact with your interface; Reoogle powers the backend. Your clients don't need to know Reoogle exists.
What's the best way to handle client onboarding?
Create a simple onboarding form that captures: client business name, website URL, product category, and the Reddit account they want to use. Then programmatically create their configuration record, securely store their API key, and trigger the first subreddit discovery run. The whole process can be automated to under 5 minutes.
How do I handle a client who wants to review posts before they go live?
Build a simple approval interface: poll /ai-posts?status=pending for the client's key, display posts in your dashboard with approve/reject buttons, and call the appropriate endpoints when the client or your team reviews them. Clients can review in your branded interface; you handle the API calls.
Can multiple team members at my agency access the same client campaigns?
The API key is the access credential — whoever has it can read and write all data for that account. For team access without sharing keys, build a thin auth layer in your backend: authenticate team members against your own system, then call the Reoogle API with the client's key server-side.
Business value
An agency managing 5 clients manually can spend 2–4 hours per client per week on Reddit. Automating discovery, scheduling, and reporting brings that to under 30 minutes per client — letting you take on 3× more clients without adding headcount.
Generate an API key from your developer dashboard and make your first request in minutes.