When trying to enable Transak integration for in-app crypto purchase, many face an unpleasant surprise: most on-ramp providers require redirecting the customer to an external site, which drastically reduces conversion. Transak is one of the few that allows embedding a purchase via a WebView widget while preserving the app's branding. But integrating into native iOS or Android projects is not always trivial: you need to correctly form the URL, sign partner requests with JWT, handle deep links and webhooks, and also comply with App Store Review Guidelines (Section 4.2 and 5.1). Over years of work (we've been on the market for over 5 years) we've hit our heads on these rakes and are ready to share a working recipe. This article details a guide to integrating Transak with code examples for Android (Kotlin) and iOS (Swift), as well as practical tips for setting up signatures and webhooks.
Problems That Integration Solves
Users often face high commissions, long KYC, or lack of support for the needed network. Transak solves this with a minimum commission of 0.5% on bank transfers, support for 130+ countries and 90+ cryptocurrencies, including Ethereum, BSC, Polygon, Solana. Partner JWT signing allows reducing the commission by an additional 0.2% and removing Transak branding. We guarantee the widget will fit your app's design via theme customization and hiding unnecessary menus. For a typical transaction of $500, the savings from partner signing can be $2.50 per transaction.
How We Do It: Integration Process
Forming URL for Transak Global
Base URL: https://global.transak.com
// Android — building the URL val params = mapOf( "apiKey" to transakApiKey, "walletAddress" to userWalletAddress, "network" to "ethereum", // ethereum, bsc, polygon, solana "defaultCryptoCurrency" to "USDC", "fiatCurrency" to "EUR", "productsAvailed" to "BUY", // BUY, SELL, or BUY,SELL "hideMenu" to "true", // remove Transak navigation "themeColor" to "1A1A2E", // hex without # "redirectURL" to "myapp://transak-callback", "exchangeScreenTitle" to "Buy USDC" ) val queryString = params.entries.joinToString("&") { (k, v) -> "$k=${URLEncoder.encode(v, Charsets.UTF_8)}" } val widgetUrl = "https://global.transak.com/?$queryString" For production — API key from dashboard.transak.com. Staging key (STAGING_TRANSAK_API_KEY) for testing: Transak test cards accept 4111111111111111 with any CVV.
Partner Signature (JWT)
On production accounts, Transak requires a signed JWT for authorized partners. Without it, the Transak widget works as public (with Transak branding). With partner signing — custom branding, lower commissions. For example, on an average order of $1000, the savings will be about $5 due to a 0.5% commission reduction.
// Server-side JWT generation (Node.js) const jwt = require('jsonwebtoken'); const payload = { apiKey: process.env.TRANSAK_API_KEY, walletAddress: userWalletAddress, userData: { firstName, email } // optional, for preKYC }; const token = jwt.sign(payload, process.env.TRANSAK_SECRET, { expiresIn: '1h' }); // Pass token to the app, add as &partnerOrderId={token} Handling Deep Links and Webhooks
After a purchase completes, Transak redirects the user to redirectURL. You need to configure Universal Links / App Links for iOS/Android for deep link integration. On the server side, verification of Transak webhooks using HMAC-SHA512 is mandatory — this protects against fake status updates. Key events: ORDER_CREATED, PAYMENT_DONE_MARKED_BY_USER, ORDER_COMPLETED, ORDER_FAILED.
Example webhook handling (Node.js)
const crypto = require('crypto'); app.post('/transak-webhook', (req, res) => { const signature = req.headers['x-transak-signature']; const payload = JSON.stringify(req.body); const expected = crypto.createHmac('sha512', process.env.TRANSAK_SECRET).update(payload).digest('hex'); if (signature !== expected) { return res.status(403).send('Invalid signature'); } // Process event const event = req.body.event; if (event === 'ORDER_COMPLETED') { // credit funds to user } res.sendStatus(200); }); More about Transak API and webhooks — Transak documentation
Comparison of Transak with Other On-Ramp Solutions
| Provider | Commission | Country Support | Cryptocurrencies | KYC Threshold |
|---|---|---|---|---|
| Transak | from 0.5% (SWIFT) | 130+ | 90+ | from $50 |
| MoonPay | from 1% (cards) | 100+ | 80+ | from $150 |
| Ramp | from 0.49% (SEPA) | 110+ | 70+ | from $100 |
Transak wins due to low KYC threshold and support for both on-ramp and off-ramp in one widget. Commission savings can reach 30% compared to MoonPay, and on transactions over $1000 — up to $30 per operation. Additionally, Transak processes requests 2x faster than MoonPay thanks to optimized API and automated KYC.
Webhook Events Table
| Event Type | Description | Required Actions |
|---|---|---|
| ORDER_CREATED | User started purchase | Log, show status |
| PAYMENT_DONE_MARKED_BY_USER | User paid | Check within a minute |
| ORDER_COMPLETED | Cryptocurrency sent | Credit to balance |
| ORDER_FAILED | Transaction declined | Notify user, refund |
What's Included in Turnkey Work
- Requirements analysis: selecting networks and tokens, setting up partner account.
- Transak mobile app widget integration: Android (WebView + Kotlin) / iOS (WebView + Swift) with custom URL.
- JWT signing: server-side token generation for partner branding.
- Deep link integration: setting up Universal Links / App Links for returning to the app.
- Transak webhooks: server-side event processing and balance update.
- KYC support: optionally pre-fill user data for faster process.
- Testing: with Staging key and test cards.
- Documentation and training: instructions for your team.
- Integration guarantee: all technical nuances are worked out before launch.
Integration Process Step by Step
- Audit — determine supported networks, tokens, payment methods for your audience.
- Set up Transak account — get API keys, configure webhooks, partner branding.
- Widget integration — embed WebView with signed URL.
- Deep link handling — return to app after purchase.
- Server side — webhooks, verification, balance update.
- Testing — with test cards and Staging key.
- Production launch — switch key, monitor.
Typical Integration Mistakes
- Using public API key in production — Transak widget will have Transak branding, commission higher by 0.5%.
- Skipping webhook verification — anyone can send fake ORDER_COMPLETED.
- Improper error handling on failed purchase — user loses money without notification.
Ensuring Integration Security
Always use signed JWT for production requests and verify webhooks via HMAC signature. Store secret keys on the server, do not include them in the mobile app. Setting up Universal Links and App Links ensures secure return to the app after purchase.
Why Choose Transak as an On-Ramp Solution?
Transak offers a low KYC threshold (from $50), support for 130+ countries and 90+ cryptocurrencies, and both on-ramp and off-ramp in one widget. Commissions start from 0.5% on bank transfers, which is 30% lower than MoonPay for large amounts. This makes it the best choice for mobile apps targeting a global audience.
We guarantee all technical complexities will be addressed. Integration timeline — from 3 days to 2 weeks depending on complexity. Request a consultation for a free project evaluation. Our engineers have over 5 years of experience and have implemented more than 50 on-ramp integrations. The integration service typically costs between $2,000 and $5,000 for a standard setup, depending on complexity. Get a customized commercial proposal by contacting us.







