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.
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.
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.
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 the public registries yet either — grab the source directly: react-native, flutter, typescript.
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.
Verification is server-side. Your app never carries a secret that could be extracted from the binary.
Change packages, pricing copy, and layout without an app release — the SDK fetches the live config.
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.
Public and gated client routes, opaque user IDs, Firebase attestation, rate limits, and plan serving behavior.
The exact per-feature capability matrix — Google Play vs Apple App Store, what's implemented vs in progress.
Sell subscriptions on the web through your own Stripe account, verified into the same entitlements.
Client SDK integration — Android (Maven), iOS (SPM), and REST-first frameworks.
Every error the API and webhooks can return, what triggers each one, and how to handle it.
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).
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.
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 }
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.
Create a project, use your agent for Tierux-side configuration, and complete required store-console work before testing purchases.
Start free