White-Label AI Platform: Multitenancy and Customization

White-Label AI-as-a-Service: Private AI Services Under Your Brand

Partners of large AI vendors often lose margin reselling public APIs—clients see the original brand and know your markup. A white-label AI platform solves this: you get a fully functional AI product that looks and works as your own. Custom domain, logo, color scheme, pricing—without revealing the technology provider.

For example, one of our partners—a SaaS company with 5,000 clients—was losing up to 70% of potential margin because clients connected directly to OpenAI. After launching a white-label platform under their own brand, they tripled the average ticket and retained all clients who previously churned to the vendor.

We have been developing white-label AI solutions for over 6 years. In that time, we have launched 14 partner platforms with combined monthly revenue in the millions of dollars. Our team of AI/ML engineers has completed over 50 projects in NLP and LLM. Below is the architecture we use in production.

Multitenant White-Label Platform Architecture

┌─────────────────────────────────────────────────────────┐
│              Partner A                Partner B          │
│    ai.company-a.com              ai.company-b.com        │
│    [Brand A UI]                  [Brand B UI]            │
└─────────────────┬────────────────────────┬──────────────┘
                  ↓                        ↓
┌─────────────────────────────────────────────────────────┐
│                White-Label Gateway                        │
│  [Tenant Resolution] → [Brand Config] → [API Proxy]     │
└─────────────────────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────────────────────┐
│                Core AI Platform                           │
│  [Model Inference] [Billing] [Analytics] [Management]   │
└─────────────────────────────────────────────────────────┘

How Is Data Isolation Ensured Between Partners?

Each partner is an isolated tenant. On each request, the Gateway identifies the tenant by domain or API key, applies its brand configuration, and proxies to the appropriate models. Data is never mixed: logs store tenant_id, billing is separate, models run in isolated containers.

According to Gartner, by the end of the decade, 80% of enterprises will use white-label AI solutions to protect their brand and control customer loyalty.

from dataclasses import dataclass

@dataclass
class WhiteLabelTenant:
    tenant_id: str
    partner_id: str
    # Branding
    brand_name: str
    logo_url: str
    primary_color: str
    custom_domain: str
    # Functionality
    enabled_models: list[str]
    custom_model_names: dict  # Rename models for partner
    # Pricing
    markup_percent: float  # Partner markup
    custom_pricing: dict   # Custom prices (override markup)
    # Contract
    revenue_share_percent: float  # % of partner revenue to us
    min_monthly_revenue: float


class TenantResolver:
    async def resolve(self, request: Request) -> WhiteLabelTenant:
        # Resolution by domain
        host = request.headers.get('host', '')

        # Search by custom domain
        tenant = await self.db.get_by_domain(host)
        if tenant:
            return tenant

        # Fallback by API key
        api_key = request.headers.get('X-API-Key')
        if api_key:
            return await self.db.get_by_api_key_prefix(api_key)

        raise TenantNotFoundError(f"Unknown domain: {host}")

Why White-Label Is Better Than Reselling a Public API?

Average partner margin after launching white-label is 200-400% compared to 20-30% with resale. Savings on branding and infrastructure reach 40%.

How We Build the White-Label Platform: Stack and Process

We use PyTorch for custom models, Hugging Face Transformers for LLMs, LangChain for RAG pipelines. Vector DBs: Qdrant/ChromaDB. Deployment on Kubernetes with Triton Inference Server. All code covered by tests and CI/CD.

Process:

1. Analytics — audit your business requirements and target scenarios (1-2 days)
2. Design — architecture, model selection, UI prototype approval (1-2 weeks)
3. Implementation — backend (Gateway, Tenant Manager, Billing), frontend (React), model integration (6-8 weeks)
4. Testing — load testing (up to 10k rps), security pentests (2-3 weeks)
5. Deployment — deploy in your cloud (AWS/GCP/Azure), configure monitoring (1 week)

Timelines: 4 to 6 months for a full white-label platform from scratch. If you already have an MVP, up to 2x faster.

Pricing is individual—we will assess the project for free, fill out the brief. Turnkey with a 12-month code warranty and post-release support.

White-Label API Gateway: Implementation

@app.middleware("http")
async def white_label_middleware(request: Request, call_next):
    tenant = await tenant_resolver.resolve(request)

    # Override brand-specific configuration
    request.state.tenant = tenant
    request.state.brand_config = await brand_config_store.get(tenant.tenant_id)

    response = await call_next(request)

    # Remove internal headers
    response.headers.pop("X-Powered-By", None)
    response.headers.pop("X-Internal-Model-Id", None)

    return response


@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest, req: Request):
    tenant = req.state.tenant

    # Map model names: "gpt-4" (client) → "actual-model-id" (internal)
    internal_model = tenant.custom_model_names.get(
        request.model,
        request.model
    )

    # Check model availability for this tenant
    if internal_model not in tenant.enabled_models:
        raise HTTPException(404, f"Model '{request.model}' not available")

    # Custom pricing
    pricing = tenant.custom_pricing.get(internal_model) or \
              base_pricing.get(internal_model) * (1 + tenant.markup_percent / 100)

    result = await inference_service.run(internal_model, request)
    await billing.charge(tenant, result.usage, pricing)

    return result

UI Customization

Partners manage branding through an admin panel:

@dataclass
class BrandConfig:
    logo_url: str
    favicon_url: str
    primary_color: str  # "#0066cc"
    secondary_color: str
    font_family: str
    custom_css: str  # Additional CSS for fine-tuning
    support_email: str
    privacy_policy_url: str
    terms_url: str
    # Whitelist of allowed features
    show_model_selection: bool = True
    show_usage_analytics: bool = True
    show_api_docs: bool = True
    custom_nav_items: list[dict] = None  # Additional menu items

{
  "tenant_id": "partner_42",
  "brand_name": "SuperAI",
  "logo_url": "https://superai.com/logo.png",
  "custom_domain": "ai.superai.com",
  "enabled_models": ["gpt-4o", "claude-3.5"],
  "custom_model_names": {"claude-3.5": "SuperChat Pro"},
  "markup_percent": 50
}

What Is Included: Deliverables

• Integration documentation: Swagger/OpenAPI, guide for partner onboarding
• Partner admin panel: manage models, pricing, users, statistics
• Custom domain and SSL: complete brand isolation
• SLA support: 99.95% uptime, incident response within 15 minutes
• Partner team training: 3-day workshop + recording
• Monitoring and alerts: via Prometheus + Grafana

Want a similar platform under your brand? Contact us—we'll estimate the project in two business days. We'll show a demo of a working partner network. Get a consultation: write to us and we will discuss your scenarios.

For reference, white-label architecture is also known as multitenancy.