Verify purchases server-side, in minutes.
Your AI agent handles Tierux-side configuration for products, entitlements, and paywalls over MCP. App Store Connect product and notification setup remains manual. Then verify purchases and read normalized entitlements from any backend over REST.
Create a project & grab your API key
Sign in and create a project — name it and pick your platform. You'll get a server-side API key. It stays on your backend / in your agent's MCP config; it's never shipped in the app.
Build your paywall
Design packages, pricing, and copy in the visual builder with a live phone preview. The config is saved server-side and fetched via the API at runtime — change it later without an app release.
Connect the MCP server to your agent
Point Claude Code, Codex, or Cursor at the Tierux MCP server — sign in with OAuth when prompted, no API key needed. Then describe what you want — the agent maps your store products, configures your paywall, and returns a preview to approve before anything is saved. Full setup steps for every client: docs-mcp-setup.
// .mcp.json { "mcpServers": { "tierux": { "url": "https://mcp-tierux.web.app" } } }
▸ "Set up a $9.99 Pro monthly subscription." create_project(name: "My App") // returns app_xxx after confirmation setup_google_play(appId: "app_xxx") create_play_product(productId: "pro_monthly", billingPeriod: "P1M", price: "9.99", currency: "USD", appId: "app_xxx") create_product_mapping(productId: "pro_monthly", entitlementId: "pro", productType: "subscription", appId: "app_xxx")
app_xxx is the public app ID returned by create_project (also shown in the dashboard). Pass it to subsequent MCP calls and to SDK initialization.
Your products and paywall are now configured server-side. Integrate from your app over the REST API (below) — or drop in the native Android SDK:
// settings.gradle.kts — add the Tierux Maven repo dependencyResolutionManagement { repositories { maven { url = uri("https://maven-tierux.web.app") } } } // app/build.gradle.kts implementation("com.tierux:android-sdk:0.2.0") // in your app — app_xxx comes from create_project or the dashboard Tierux.init(context, appId = "app_xxx", baseUrl = "https://tierux.com/") Tierux.showPaywall(activity, paywallId = "pro") { result -> when (result) { is PaywallResult.Purchased -> if (result.active) unlockPro() PaywallResult.Cancelled -> Unit is PaywallResult.Error -> showError(result.error) is PaywallResult.WinbackAccepted -> unlockPro() } }
The Android Maven registry is live at https://maven-tierux.web.app. You can also download the Android SDK source for local integration (no API key needed).
iOS SDK source — browse or download the full Swift source (no API key needed). Extract and reference locally with SPM (.package(path: "Tierux")) or use the REST API directly.
React Native, Flutter, and the TypeScript backend SDK aren't on public package registries yet — grab the source directly: react-native, flutter, typescript.
Verify a purchase
Send a real purchase token to the verify endpoint (below). Tierux verifies it with the store and normalizes it into queryable entitlement state, with the verification showing live in your dashboard. Raw purchase tokens are never stored.
No client API key
Verification is server-side. Your app never carries a secret that could be extracted from the binary.
Remote paywall config
Change packages, pricing copy, and layout without an app release — the SDK fetches the live config.
Android + iOS
Android SDK com.tierux:android-sdk:0.2.0 is live via the self-hosted Maven registry. iOS Swift SDK source is served via API for audit and local integration; App Store server-side verification ships today.
The steps above are the quickstart. The reference below is the long version, in reading order — ten chapters covering agent setup, the client SDKs, the client trust model, verification on each store, store notifications, error handling, per-platform status, and the web store. Read it end to end when you are wiring up a new integration, or jump to the chapter matching the problem in front of you. Each chapter links to the next, so you can follow the order without coming back here.
Chapter 1: MCP Setup
Use your AI agent for Google Play infrastructure and Tierux-side product configuration. App Store Connect product and notification setup remains manual before SDK integration.
Chapter 2: SDKs
Client SDK integration — Android (Maven), iOS (SPM), and REST-first frameworks.
Chapter 3: Client authentication
Public and gated client routes, opaque user IDs, Firebase attestation, rate limits, and plan serving behavior.
Chapter 4: Purchase Token Validation
How store evidence is verified, hashed, and encrypted server-side.
Chapter 5: StoreKit Verification
Deep dive on Apple StoreKit 2 JWS verification used by the iOS SDK.
Chapter 6: RTDN
Google Play real-time developer notification handling and entitlement state sync.
Chapter 7: Webhooks
General webhook handling — RTDN, App Store Notifications, and custom webhook configuration.
Chapter 8: Error Codes
Every error the API and webhooks can return, what triggers each one, and how to handle it.
Chapter 9: Platform Support
The exact per-feature capability matrix — Google Play vs Apple App Store, what's implemented vs in progress.
Chapter 10: Stripe Web Store
Sell subscriptions on the web through your own Stripe account, verified into the same entitlements.
Server-side verification guide
The long-form version of this page: purchase token handling, the entitlement state machine, store notifications, and mapping products to entitlements.
This is how you integrate today — from any backend, in any language, with nothing but your server-side API key and an HTTP client. Authenticate every request with Authorization: Bearer <your-api-key>; the base URL is https://tierux.com/api. The native Android SDK wraps these same endpoints; iOS SDK source is available for download (local SPM integration).
Verify a purchase
After a user buys in your app, send the store's purchase token to Tierux. It verifies with Google Play (or Apple), then normalizes the result into entitlement state. Raw tokens are never stored.
curl -X POST https://tierux.com/api/v1/purchases/google-play/verify \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "appId": "app_123", "userId": "user_abc", "packageName": "com.yourco.app", "productId": "pro_monthly", "purchaseToken": "token-from-google-play-billing" }'
// 200 OK { "ok": true, "userId": "user_abc", "entitlement": "pro", "active": true, "expiresAt": "2026-07-25T00:00:00.000Z", "status": "active" }
On iOS, post the StoreKit 2 JWS to /api/v1/purchases/apple/verify with transactionId and jwsRepresentation instead of packageName / purchaseToken.
Check an entitlement
Gate a feature from your backend by reading the user's current entitlement state. active reflects renewals, expiry, and cancellations kept in sync by store notifications.
curl https://tierux.com/api/v1/entitlements/user_abc/pro \ -H "Authorization: Bearer YOUR_API_KEY"
// 200 OK { "userId": "user_abc", "entitlement": "pro", "active": true, "expiresAt": "2026-07-25T00:00:00.000Z", "status": "active", "winbackPending": false }
Where do I get an API key?
Create a project in the dashboard and copy the key shown once on creation (rotate it anytime under the project's settings). It's a server-side secret — keep it on your backend, never in client code.
Ready to wire it up?
Create a project, use your agent for Tierux-side configuration, and complete required store-console work before testing purchases.
Start free