PlayableAd Studio's API-first architecture makes it directly embeddable into third-party agency and ad-network platforms, creating a turnkey white-label sales channel. Any business with existing advertiser relationships can resell AI-powered playable ad generation under their own brand -- without building their own LLM infrastructure, game engine pipeline, or cloud rendering stack.
The Problem
Playable ads convert 2-5x better than video or static display ads, but producing them remains bottlenecked by specialized skills. A single playable ad traditionally requires a Unity/Cocos developer, a creative director, a QA cycle, and multiple revision rounds. Production costs range from $1,500 to $8,000 per ad, with 2-3 week turnaround times.
For ad networks, agencies, and DSP platforms that serve hundreds of advertiser accounts, this bottleneck is existential. They cannot afford to:
- Hire dedicated game development teams for every campaign
- Maintain their own Cocos Creator or Unity pipelines
- Build and serve LLM infrastructure for prompt-to-ad generation
- Manage cloud rendering, storage, and CDN distribution at scale
Yet their advertisers increasingly demand interactive ad formats. Ad networks that cannot offer playable ads lose contracts to competitors who can. The gap between what advertisers want and what platforms can deliver is widening every quarter.
The Solution
PlayableAd Studio solves this with a white-label reseller architecture. Third-party agencies and ad networks integrate once via the API and instantly offer playable ad generation under their own brand. The architecture has four layers of white-label customization:
| Layer | Customization | Implementation |
|-------|--------------|----------------|
| Domain | Custom subdomain or CNAME | Cloudflare Workers routes via custom host header |
| UI Theme | Brand colors, logos, fonts | CSS variable injection + theme JSON at integration time |
| Ad Output | Branded watermark on generated ads | Server-side overlay via Canvas API on R2 output |
| Billing | Credit-based, usage metering via API | Reseller sets price per generation; Studio handles infra |
A reseller flow looks like this:
1. Reseller signs a partnership agreement and receives an API key with `reseller` scope
2. Reseller configures their theme JSON (logo URL, primary color, accent color, font stack)
3. Reseller points a CNAME record to PlayableAd Studio's Workers router
4. End advertisers visit the branded site, generate playable ads via prompt
5. Each generation deducts from the reseller's credit pool, billed at the reseller's markup
6. PlayableAd Studio handles rendering, hosting, and delivery -- invisible to the end user
Architecture
The white-label pipeline uses three Cloudflare primitives and a credit-metering API gateway:
```
┌─────────────────────────────────────────────────────┐
│ Reseller's Brand │
│ (adnetwork.example/playable) │
└──────────┬──────────────────────────────────────────┘
│
▼ CNAME / custom domain
┌─────────────────────────────────────────────────────┐
│ Cloudflare Workers Router │
│ - Reads host header → resolves tenant ID │
│ - Injects tenant theme, branding, watermark config │
│ - Routes to PlayableAd Studio core │
└──────────┬──────────────────────────────────────────┘
│
┌──────────▼──────────────────────────────────────────┐
│ API Gateway (credit-metering middleware) │
│ - Validates API key + tenant scopes │
│ - Checks credit balance before generation │
│ - Deducts credits on successful render │
│ - Logs usage to D1 for reseller billing reports │
└──────────┬──────────────────────────────────────────┘
│
┌──────────▼──────────────────────────────────────────┐
│ PlayableAd Generation Pipeline │
│ - LLM prompt → structured ad config │
│ - Cocos Creator headless render → HTML5 ad │
│ - Canvas watermark overlay → R2 storage │
│ - CDN delivery via Workers │
└─────────────────────────────────────────────────────┘
```
The key architectural decision: the watermark overlay happens **server-side** at the R2 output stage, not in the browser. This ensures the end advertiser cannot strip the reseller's branding from the generated ad.
```javascript
// Simplified watermark overlay (Cloudflare Worker)
async function applyWatermark(image, tenantConfig) {
const { logoUrl, brandName, opacity } = tenantConfig;
// Fetch logo, composite onto ad output frame
const logo = await fetch(logoUrl);
const canvas = new OffscreenCanvas(1080, 1920);
const ctx = canvas.getContext('2d');
ctx.drawImage(await createImageBitmap(image), 0, 0);
ctx.globalAlpha = opacity || 0.15;
ctx.drawImage(await createImageBitmap(logo), 24, 24);
return canvas.convertToBlob();
}
```
Implementation Details
Tenant Configuration Store
Each reseller tenant has a JSON configuration stored in D1. The Worker fetches this at request time via the host header:
```sql
-- D1 schema for tenant config
CREATE TABLE tenants (
id TEXT PRIMARY KEY,
domain TEXT UNIQUE NOT NULL,
name TEXT NOT NULL,
theme_json TEXT NOT NULL, -- colors, fonts, logo URL
watermark_config TEXT NOT NULL, -- position, opacity, logo
credit_balance INTEGER DEFAULT 0,
credit_price_per_unit REAL DEFAULT 1.00,
created_at TEXT DEFAULT (datetime('now'))
);
CREATE TABLE usage_logs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tenant_id TEXT NOT NULL,
ad_id TEXT NOT NULL,
credits_used INTEGER NOT NULL,
generated_at TEXT DEFAULT (datetime('now')),
FOREIGN KEY (tenant_id) REFERENCES tenants(id)
);
```
API Endpoints for Reseller Integration
The reseller-facing API exposes three core endpoints:
| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/v1/reseller/ads/generate` | POST | Submit a prompt, get back a playable ad URL |
| `/v1/reseller/ads/:id` | GET | Retrieve ad metadata and delivery URL |
| `/v1/reseller/credits` | GET | Check remaining credit balance |
| `/v1/reseller/usage` | GET | Paginated usage report for billing |
| `/v1/reseller/theme` | PUT | Update brand theme (colors, logo, watermark) |
Authentication uses a reseller-scoped API key passed via the `X-API-Key` header. The Worker middleware validates the key, extracts the tenant ID, and passes it downstream.
Billing Flow
PlayableAd Studio bills the reseller at a wholesale rate per generation. The reseller sets their own retail price. The system tracks usage per tenant and generates monthly invoices via the D1 usage logs:
```
Wholesale cost: $0.50 per playable ad generation
Reseller price: $2.00 per playable ad generation (configurable)
Reseller margin: $1.50 per ad (75% gross margin)
At 500 ads/month: $750 monthly gross profit for the reseller
At 5,000 ads/month: $7,500 monthly gross profit
```
Custom Domain Setup
The reseller configures a CNAME record pointing their subdomain (e.g., `playable.agencyname.com`) to `playablead.studio`. The Workers router reads the `Host` header and looks up the tenant config:
```javascript
// Domain routing in Cloudflare Worker
addEventListener('fetch', event => {
const url = new URL(event.request);
const host = url.hostname;
// Look up tenant by domain
const tenant = TENANTS.get(host);
if (!tenant) {
return event.respondWith(new Response('Tenant not found', { status: 404 }));
}
// Inject tenant theme into response
const response = await handleRequest(event.request, tenant);
return event.respondWith(response);
});
```
Themed UI Injection
The frontend is served as a single-page application with CSS custom properties injected at the edge. The Worker reads the tenant's `theme_json` and injects it into the HTML response:
```html
<style>
:root {
--brand-primary: {{tenant.theme.primaryColor}};
--brand-secondary: {{tenant.theme.secondaryColor}};
--brand-logo: url('{{tenant.theme.logoUrl}}');
--brand-font: '{{tenant.theme.fontFamily}}', sans-serif;
}
</style>
```
Results / Metrics
Since launching the white-label channel in Q1 2026, PlayableAd Studio has onboarded 12 reseller tenants. Aggregate metrics across the channel:
| Metric | Value |
|--------|-------|
| Average reseller onboarding time | 2.3 hours (API integration + CNAME + theme config) |
| Median monthly ads per reseller | 1,240 |
| Average reseller margin | 68% (after wholesale cost) |
| Reseller churn (quarterly) | 0% (zero tenants lost) |
| End-advertiser NPS (via resellers) | 72 |
| Largest single reseller volume | 8,700 ads/month |
| Average time-to-first-ad for new reseller | 4.7 days (including their internal approval) |
One mid-size ad network reseller reported that adding PlayableAd Studio to their product suite increased their average contract value by 22% and won them two competitive pitches they previously lost to a larger DSP that had in-house playable ad production.
Key Takeaways
1. **API-first design unlocks the channel.** PlayableAd Studio was built with a clean API from day one, making white-label resale a configuration change rather than a fork or separate deployment. Any SaaS product considering a reseller channel should prioritize API-first architecture before building partner tooling.
2. **Server-side watermarking is non-negotiable.** If the branding overlay can be stripped client-side, the white-label model collapses. By applying watermarks at the R2 output stage, the reseller's brand is permanently baked into every generated ad.
3. **Credit-based billing simplifies reseller economics.** A prepaid credit pool with configurable per-unit pricing lets resellers set their own margins without requiring complex SaaS metering infrastructure on their side. PlayableAd Studio handles metering and collection wholesale.
4. **Onboarding speed drives adoption.** A 2.3-hour onboarding time -- configure a CNAME, paste a theme JSON, get an API key -- removes the sales friction that kills reseller programs. Every hour of complexity in onboarding reduces partner conversion by measurable percentages.
5. **The reseller channel creates a flywheel.** Each reseller brings their own advertiser base, which generates usage data that improves the LLM prompt models, which makes better ads, which increases usage. Meanwhile, PlayableAd Studio never needs to build its own direct sales team for markets the resellers already own.
6. **Wholesale margins compound at scale.** At $0.50 wholesale per ad, the infrastructure cost is negligible compared to the value delivered. A reseller generating 5,000 ads/month at $2.00 retail earns $7,500/month in gross profit -- more than enough to justify the partnership. For PlayableAd Studio, the revenue is recurring and scales linearly with no additional sales cost per transaction.