White-Label AI Platform: Rebrand, Resell, and Scale AI SaaS

TL;DR — A white-label AI platform enables partners to rebrand and resell AI SaaS under their own brand. Developex defines it: "a software delivery model where a provider develops a core platform that multiple partners rebrand and resell as their own. While the underlying infrastructure is shared, each tenant enjoys a unique, branded experience." Key features: custom domains (platform.client-brand.com), per-tenant theming (CSS-level control), white-labeled AI chat (no vendor attribution), reseller hierarchy (platform → reseller → end-client), custom pricing per reseller, and API access under reseller's domain. Lety.ai provides "a ready-made foundation to own your AI SaaS — every assistant carries your logo, your domain, your pricing, your rules." Omni Analytics notes "per-tenant theming for reseller and OEM scenarios" with "white-labeled AI chat that does not say 'Powered by Vendor X'." Architecture: multi-tenant with per-tenant branding, BYOK for enterprise, cost tracking, and usage metering.

Developex describes the white-label SaaS model: "A provider develops a 'core' platform that multiple partners rebrand and resell as their own. While the underlying infrastructure is shared, each 'tenant' (client) enjoys a unique, branded experience."

CustomGPT.ai emphasizes the value proposition: "Full Branding Control: Customize the interface, domain, and client experience under your brand, creating the impression of proprietary technology from day one."

White-Label AI Platform Architecture

Reseller Hierarchy

Branding Customization Matrix

Implementation

class WhiteLabelPlatform:
    """White-label AI platform with reseller hierarchy and branding."""

    def __init__(self, config):
        self.db = config.db
        self.cdn = config.cdn  # For logo/favicon/theme assets
        self.dns = config.dns  # For custom domain management
        self.billing = config.billing

    async def create_reseller(self, reseller_data: dict) -> dict:
        """Onboard a new reseller with custom branding."""
        reseller_id = str(uuid4())

        # Store reseller branding configuration
        branding = await self.db.insert("resellers", {
            "id": reseller_id,
            "name": reseller_data["name"],
            "domain": reseller_data["domain"],
            "theme": {
                "primary_color": reseller_data.get("primary_color", "#0066CC"),
                "secondary_color": reseller_data.get("secondary_color", "#6B7280"),
                "logo_url": await self.cdn.upload(reseller_data["logo"]),
                "favicon_url": await self.cdn.upload(reseller_data["favicon"]),
                "css_overrides": reseller_data.get("css_overrides", ""),
            },
            "model_names": reseller_data.get("model_names", {}),
            "email_config": {
                "from_address": f"noreply@{reseller_data['domain']}",
                "template_overrides": reseller_data.get("email_templates", {}),
            },
            "pricing": {
                "platform_cost_per_1m_tokens": 1.00,  # What reseller pays
                "reseller_pricing": reseller_data.get("client_pricing", {
                    "starter": {"monthly": 29, "tokens_per_day": 50000},
                    "pro": {"monthly": 99, "tokens_per_day": 200000},
                    "enterprise": {"monthly": 499, "tokens_per_day": 1000000},
                }),
            },
            "created_at": datetime.utcnow(),
        })

        # Set up custom domain
        await self.dns.create_cname(
            domain=reseller_data["domain"],
            target=f"{reseller_id}.platform.app-lab.ai",
        )

        # Provision TLS certificate
        await self.dns.provision_tls(reseller_data["domain"])

        return {"reseller_id": reseller_id, "status": "active"}

    async def get_theme(self, domain: str) -> dict:
        """Load branding theme for a domain."""
        reseller = await self.db.find_one(
            "resellers",
            {"domain": domain}
        )

        if not reseller:
            return self.default_theme()  # Platform's own branding

        return {
            "reseller_id": reseller["id"],
            "logo_url": reseller["theme"]["logo_url"],
            "primary_color": reseller["theme"]["primary_color"],
            "secondary_color": reseller["theme"]["secondary_color"],
            "css_overrides": reseller["theme"]["css_overrides"],
            "model_names": reseller["model_names"],
            "ai_assistant_name": reseller.get("ai_assistant_name", "AI Assistant"),
        }

    async def create_client(self, reseller_id: str, client_data: dict) -> dict:
        """Reseller creates a new end-client under their brand."""
        client_id = str(uuid4())
        plan = client_data.get("plan", "starter")

        # Get reseller's pricing for this plan
        reseller = await self.db.find_one("resellers", {"id": reseller_id})
        pricing = reseller["pricing"]["reseller_pricing"][plan]

        client = await self.db.insert("clients", {
            "id": client_id,
            "reseller_id": reseller_id,
            "name": client_data["name"],
            "plan": plan,
            "tokens_per_day_limit": pricing["tokens_per_day"],
            "monthly_fee": pricing["monthly"],
            "created_at": datetime.utcnow(),
        })

        return {"client_id": client_id, "plan": plan, "monthly_fee": pricing["monthly"]}

    async def meter_usage(self, reseller_id: str, client_id: str, 
                          tokens_used: int, model: str):
        """Track usage for both platform-to-reseller and reseller-to-client billing."""
        # Platform charges reseller
        platform_cost = (tokens_used / 1_000_000) * 1.00  # $1.00 per 1M tokens

        await self.billing.record({
            "reseller_id": reseller_id,
            "client_id": client_id,
            "tokens_used": tokens_used,
            "model": model,
            "platform_cost": platform_cost,
            "timestamp": datetime.utcnow(),
        })

        # Check if client exceeded daily token limit
        daily_usage = await self.billing.get_daily_usage(client_id)
        client = await self.db.find_one("clients", {"id": client_id})

        if daily_usage >= client["tokens_per_day_limit"]:
            raise QuotaExceededError(
                f"Daily token limit ({client['tokens_per_day_limit']}) exceeded"
            )

Pricing Model

White-Label AI Platform Checklist

• [ ] Build multi-tenant architecture with strict data isolation
• [ ] Implement reseller hierarchy: platform → reseller → end-client
• [ ] Set up custom domain support (CNAME + TLS provisioning)
• [ ] Implement per-reseller theming (logo, colors, CSS overrides)
• [ ] Configure white-labeled AI chat (no vendor attribution)
• [ ] Set up custom model naming per reseller
• [ ] Implement branded email templates per reseller
• [ ] Set up custom API domain per reseller
• [ ] Configure branded PDF/report generation
• [ ] Implement per-reseller admin dashboard for client management
• [ ] Set up per-reseller pricing controls (Starter, Pro, Enterprise)
• [ ] Implement platform-to-reseller usage billing
• [ ] Implement reseller-to-client billing
• [ ] Set up usage metering per tenant
• [ ] Configure per-tenant cost tracking and quotas
• [ ] Implement per-tenant token limits (daily and monthly)
• [ ] Set up per-tenant rate limiting
• [ ] Configure per-tenant RBAC (Admin, Editor, Viewer)
• [ ] Implement per-tenant audit logging
• [ ] Support BYOK for enterprise clients
• [ ] Set up per-tenant knowledge base isolation
• [ ] Implement per-tenant agent configurations
• [ ] Configure per-tenant analytics dashboard
• [ ] Set up SSO integration per tenant (SAML, OIDC)
• [ ] Implement per-tenant feature flags
• [ ] Set up reseller onboarding flow (branding, domain, pricing)
• [ ] Set up client onboarding flow (reseller-managed)
• [ ] Implement reseller support tier (first-line for clients)
• [ ] Set up platform-level support (infrastructure, model updates)
• [ ] Apply zero-trust architecture between tenants
• [ ] Apply OWASP LLM Top 10 security controls
• [ ] Set up platform monitoring per reseller
• [ ] Consider self-hosted AI for data sovereignty
• [ ] Implement volume discounts for resellers as they scale
• [ ] Set up reseller agreement and terms of service
• [ ] Document API for reseller integration
• [ ] Quarterly review: reseller performance, client satisfaction, margin analysis
• [ ] Consider AI incident response for platform issues

FAQ

What is a white-label AI platform?

A white-label AI platform is a rebrandable AI SaaS that allows partners to resell AI capabilities under their own brand. The platform provider builds the core infrastructure (LLM serving, RAG, agents, vector databases), while resellers customize the branding (logo, colors, domain, UI), set their own pricing, and manage their own clients. Key features: custom domains (client.platform.com or platform.client-brand.com), per-tenant theming (CSS-level control), white-labeled AI chat (no 'Powered by Vendor X'), reseller hierarchy (platform → reseller → end-client), custom pricing per reseller, and API access for integration. The underlying infrastructure is shared (multi-tenant), but each reseller's clients see only the reseller's brand.

How does white-label AI SaaS branding work?

White-label AI SaaS branding works through per-tenant theming and custom domains. Each reseller gets: (1) Custom domain — CNAME or DNS routing to platform.client-brand.com. (2) Logo and favicon — uploaded by reseller, displayed on all UI surfaces. (3) Color scheme — CSS variables for primary, secondary, accent colors. (4) Email templates — branded notifications and reports. (5) AI chat interface — no 'Powered by' attribution, reseller's brand only. (6) Custom model names — reseller can rename 'GPT-4o' to 'AcmeAI Pro'. (7) White-labeled API — endpoints under reseller's domain. (8) PDF/report branding — reseller's logo and colors on all generated documents. Implementation: theme configuration per tenant, dynamic CSS loading, CDN for custom domains.

What is the reseller hierarchy in white-label AI platforms?

The reseller hierarchy in white-label AI platforms has three tiers: (1) Platform provider — builds and maintains the core AI infrastructure (you). (2) Reseller — brands and sells the platform to end-clients (your partner). (3) End-client — uses the AI platform under the reseller's brand. Each reseller manages their own clients, sets their own pricing, and handles first-line support. The platform provider handles infrastructure, model updates, and platform-level support. Implementation: tenant hierarchy in database (platform_tenant_id, reseller_tenant_id, client_tenant_id), per-reseller feature flags, per-reseller pricing overrides, reseller admin dashboard for client management, and per-reseller usage metering for platform-to-reseller billing.

How do you price a white-label AI platform?

White-label AI platform pricing has two layers: (1) Platform-to-reseller pricing — the platform provider charges resellers based on usage (tokens, API calls, storage) or a flat monthly fee per reseller. Typical: $0.50-2.00 per 1M tokens + $50-500/month base fee. (2) Reseller-to-client pricing — resellers set their own prices for end-clients. Typical: $29-99/month for Pro, $99-499/month for Business, $499+/month for Enterprise. Resellers keep the margin between what they charge clients and what the platform charges them. Platform provider should offer volume discounts to resellers as they scale. Consider tiered plans (Starter, Pro, Enterprise) with different feature sets and token allowances.

What features should a white-label AI platform include?

Essential features: (1) Multi-tenant architecture with strict data isolation. (2) Custom domains and per-tenant theming. (3) Reseller hierarchy with per-reseller admin dashboard. (4) Per-reseller and per-client pricing controls. (5) Usage metering and billing (platform-to-reseller and reseller-to-client). (6) White-labeled AI chat (no vendor attribution). (7) Custom model naming. (8) API access under reseller's domain. (9) RAG with per-tenant knowledge bases. (10) Agent builder with per-tenant configurations. (11) Per-tenant analytics dashboard. (12) Email/notification branding. (13) SSO integration per tenant. (14) Per-tenant RBAC. (15) Audit logging per tenant. (16) BYOK support for enterprise clients. (17) Cost tracking and quotas.

Want a self-hosted AI company brain that does all of this out of the box?
Book a demo →