Platform Model
Azotte operates as a subscription orchestration layer that sits between your business logic and the complexity of multi-channel subscription commerce. This document explains the platform's entity model, how the components relate to each other, and how they integrate into your system.
Entity Relationship Overview
Tenant
A Tenant is the root-level isolation boundary. It represents your organization within Azotte. All data — storefronts, customers, subscriptions, configurations — is scoped to the tenant and completely isolated from other tenants on the platform.
When you integrate with Azotte, a tenant is provisioned for your organization. Every API request you make includes your tenant identifier (via the x-tn header), and all operations execute within that boundary. There is no cross-tenant data leakage by design.
A single tenant can support multiple environments (development, staging, production), each with its own configuration set.
Storefront
Storefronts are the central integration point. A storefront represents a distinct sales channel — a website, a mobile app, a partner white-label experience, or a telecom carrier billing flow. Each storefront is configured independently, giving you full control over what is sold, how it is paid for, and which subscription channels manage the lifecycle.
A storefront owns the following relationships:
- Bundles — which subscription products are available for purchase in this channel
- Customers — the end users who purchase through this channel
- Subscription Channels — which systems manage the subscription lifecycle
- Payment Providers — which PSPs process payments for this channel
- Fiscalization Provider — which tax/fiscal compliance system issues invoices
This means you can run a web storefront with Stripe as the payment provider and a mobile storefront that delegates subscription management to the AppStore — both under the same tenant, sharing the same bundle catalog or offering completely different products.
Bundles and Entitlements
Bundles are what your customers purchase. A bundle is a packaged subscription offering that groups one or more entitlements together.
Entitlements are the atomic units of access. They define what a customer gets: feature flags, service tiers, usage quotas, content access. Entitlements are defined independently and then composed into bundles.
The same entitlement can appear in multiple bundles. When a customer subscribes to a bundle, they receive all entitlements associated with it. Your application checks entitlements at runtime — via API, SDK, or JWT token claims — to gate access to features and services.
This separation between bundles (commercial packaging) and entitlements (technical access control) means you can restructure your pricing and product tiers without changing your application's authorization logic.
Subscription Channels
Subscription channels define where and how a subscription lifecycle is managed. A storefront connects to one or more channels, and each channel represents a different subscription management pathway:
| Channel | Purpose |
|---|---|
| Azotte | Direct subscription management through the Azotte platform — full lifecycle control, billing, and entitlement provisioning |
| AppStore | Apple App Store in-app purchases — Azotte synchronizes subscription state from App Store Server Notifications |
| PlayStore | Google Play billing — Azotte synchronizes subscription state from Google Real-Time Developer Notifications |
| PayPal | PayPal subscription billing — subscriptions created and managed through PayPal's billing agreements |
| Third-Party Telecom | Carrier billing through telecom partners — enables subscriptions charged directly to a mobile phone bill |
When integrating, you configure which channels are available per storefront. Regardless of the originating channel, Azotte normalizes the subscription state and entitlement grants into a unified model that your backend consumes through a single API surface.
Payment Flow
The payment path flows through three systems: the Payment Provider, Azotte's payment engine, and the Fiscalization Provider.
Payment Provider
Each storefront is configured with one or more Payment Service Providers (PSPs). Azotte supports major providers (Stripe, Adyen, PayPal, Braintree) as well as regional providers for localized payment methods. The platform's payment orchestration layer scores and routes transactions to the optimal PSP based on geography, success rates, cost, and feature requirements. If the primary PSP fails, the transaction automatically cascades to backup providers.
Payment Processing
Once routed, Azotte manages the full payment lifecycle: authorization, capture, and settlement. For recurring subscriptions, this runs automatically on each billing cycle. Failed payments trigger a retry sequence with configurable intervals before the subscription is suspended.
Fiscalization and Invoicing
After a payment is processed, it flows to the storefront's configured Fiscalization Provider. The fiscalization provider handles tax compliance, fiscal reporting, and invoice generation according to local regulations. The output is a compliant invoice tied to the original payment.
Customer and Subscription Lifecycle
Customers exist within the scope of a storefront. When a customer subscribes to a bundle, a Subscription object is created that links the customer to the bundle and drives the billing and entitlement lifecycle.
The subscription progresses through well-defined states:
- Trial — time-limited evaluation period before billing begins
- Active — subscription is current, payments are successful, entitlements are granted
- Grace — a payment has failed; the subscription remains active while retries are attempted
- Suspended — all retries exhausted; entitlements are revoked until payment is resolved
- Cancelled — terminated by the customer or by the system
- Expired — reached end of a fixed-term subscription
Your application reacts to these state changes through webhooks, allowing you to provision or revoke access in real time without polling.
Integration Model
From an integration perspective, Azotte sits between your application and the payment/subscription infrastructure:
Your application interacts with a single API surface. Azotte handles the complexity of multi-channel subscription synchronization, payment routing and failover, entitlement resolution, and fiscal compliance behind that surface.
All API requests are scoped to your tenant and authenticated via API keys. Subscription state changes, payment events, and entitlement updates are pushed to your application via webhooks, so your system stays synchronized without polling.