Bring your app onchain in minutes through Starkzap

tl;dr: Starkzap is an open-source TypeScript SDK that lets you bring your app onchain in minutes and bring bitcoin to your users in minutes. one npm install, everything from social login, gasless transactions via AVNU paymaster. bitcoin, stablecoins, swaps, staking, lending all in one SDK. web, React Native, Node.js. no blockchain developer needed.

you want bitcoin in your app or stablecoin payments or token rewards that actually mean something

you've seen the demos, you've read the threads, and you're convinced onchain is the future of your product.

then you actually try to build it.

suddenly you're drowning in wallet adapters, RPC endpoints, gas estimation, seed phrase UX, bridge integrations, and five different SDKs that don't talk to each other. what was supposed to be a weekend project turns into a two-month odyssey that requires hiring a blockchain developer you can't afford.

this is the gap. the distance between "i want bitcoin in my app" and "my users are actually earning bitcoin in my app" is enormous. the distance between "i want to go onchain" and "my app is onchain" is enormous. and it's the single biggest reason most founders and developers never ship.

Starkzap closes that gap to minutes. not days. not weeks. minutes. one npm install. a few lines of TypeScript. your app is onchain. your users have bitcoin. no blockchain developer needed.

let me show you how.

the real cost of adding blockchain to your app

here's what going onchain actually looks like today if you're building from scratch:

wallets. your users need a wallet. that means seed phrases (12 random words they'll definitely lose), browser extensions (good luck on mobile), and a signup flow that scares away 95% of normies before they even start.

gas fees. every transaction costs gas. your users need to hold the right gas token on the right network before they can do anything. try explaining that to someone who just wants to send $5.

RPCs and nodes. you need a connection to the blockchain. that means picking an RPC provider, managing rate limits, handling network errors, and dealing with different endpoints for different networks.

account abstraction. the solution to most of these UX problems exists, but implementing it yourself means understanding ERC-4337, bundlers, paymasters, entry points, and a stack of infra that wasn't designed for someone who just wants to add a "pay with crypto" button.

bridges. want bitcoin in your app? cool, bitcoin lives on its own chain. you need a bridge, a wrapper token, and another set of smart contract integrations. want assets from Ethereum or Solana? more bridges, more complexity.

the bill. stitching all of this together takes 4-8 weeks of engineering time, a dedicated blockchain developer (easily $150K+/year), and the ongoing maintenance burden of keeping 5-10 different libraries in sync.

most founders look at this and (rightfully) say: not worth it.

but what if none of this was your problem?

how Starkzap makes blockchain integration effortless

Starkzap is an open-source TypeScript crypto SDK that handles all of the above. the entire blockchain integration layer becomes somebody else's problem. here's what you get:

one install, one SDK, one API

npm install starkzap

that's it. no wallet adapters, no separate paymaster libraries, no bridge SDKs. one package, one import, one consistent API surface across web, mobile, and server. check it on npm or GitHub.

social login (no seed phrases, ever)

your users sign in with google, apple, email, SMS, discord, twitter, or passkeys. they never see a wallet address. they never write down 12 words. they never install a browser extension.

this is powered by Privy (for consumer apps) and Cartridge Controller (for gaming), both integrated directly into the SDK:

import { StarkZap, OnboardStrategy } from "starkzap";

const sdk = new StarkZap({ network: "mainnet" });

const { wallet } = await sdk.onboard({
  strategy: OnboardStrategy.Privy,
  deploy: "if_needed",
  feeMode: "sponsored",
});

// that's it. user has a wallet. they signed in with google.
// they have no idea they're on a blockchain. that's the point.

gasless transactions (users never pay gas)

configure the AVNU paymaster and your users never see a gas fee. you sponsor it, or they pay in stablecoins (USDC, USDT) instead of needing a specific gas token. either way, the word "gas" never enters their vocabulary:

const sdk = new StarkZap({
  network: "mainnet",
  paymaster: {
    nodeUrl: "https://starknet.paymaster.avnu.fi",
    apiKey: "your-api-key",
  },
});

// every transaction is now sponsored. users pay nothing.
const tx = await wallet.execute([call], { feeMode: "sponsored" });

the Starknet Foundation even runs a Propulsion Program offering up to $1M in gas subsidies for qualifying projects. free gas for your users, paid for by the ecosystem.

bitcoin in your app in minutes

this is the headline. strkBTC gives your users bitcoin on Starknet with shielded, private balances. no bridges to manage. no wrapper tokens to explain. no bitcoin node to run. it is just bitcoin, in your app, with privacy built in. bring bitcoin to your application in minutes that is not marketing copy, that is the actual integration timeline.

your fitness app can reward users with bitcoin for completing a run. your productivity app can let users stake bitcoin as a commitment device. your gaming app can pay out bitcoin rewards. all of this works today, right now, with the same npm install starkzap you already ran.

want to go further? the SDK integrates Tongo protocol for fully confidential transfers where amounts are hidden on-chain. fund a private balance, transfer confidentially, withdraw back to public. bitcoin plus privacy, in minutes.

cross-platform: web, mobile, React Native, server

the same API works in Node.js, browsers, and React Native. build a web app with Vite, a mobile app with Expo, or a backend service with Express. same starkzap import, same methods, same behavior.

for React Native, install @starkzap/native and you get iOS and Android support with the same onboarding flows. mobile developers searching for a blockchain SDK with React Native support, this is it.

DeFi, swaps, staking, and bridging built in

token transfers, balance checks, staking, lending (via Vesu), swaps (via AVNU and Ekubo), bridging from Ethereum and Solana, and a transaction builder for batching multiple operations into a single call. it's all there. for a deep dive into every financial primitive, read the complete money toolkit guide.

full TypeScript integration example: onboard, check balance, transfer

here's the complete flow for onboarding a user, checking their balance, and sending a transfer. this is the entire blockchain integration:

import { StarkZap, OnboardStrategy, getPresets, Amount, fromAddress } from "starkzap";

// 1. initialize
const sdk = new StarkZap({
  network: "mainnet",
  paymaster: {
    nodeUrl: "https://starknet.paymaster.avnu.fi",
    apiKey: "your-api-key",
  },
});

// 2. onboard user (social login, wallet creation, deployment  all automatic)
const { wallet } = await sdk.onboard({
  strategy: OnboardStrategy.Privy,
  privy: {
    resolve: async () =>
      fetch("https://your-api.example/signer-context", {
        headers: { Authorization: `Bearer ${accessToken}` },
      }).then((r) => r.json()),
  },
  deploy: "if_needed",
  feeMode: "sponsored",
});

// 3. check balance
const STRK = getPresets(wallet.getChainId()).STRK;
const balance = await wallet.balanceOf(STRK);
console.log(balance.toFormatted()); // "150.25 STRK"

// 4. send tokens (gasless  user pays nothing)
const tx = await wallet.transfer(STRK, [
  { to: fromAddress("0xRECIPIENT"), amount: Amount.parse("10", STRK) },
]);
await tx.wait();
console.log(tx.explorerUrl); // done.

that's social login, wallet creation, account deployment, balance checks, gasless transfers, and explorer links. in about 20 lines of code. your existing TypeScript developers can ship this in a day.

ready to try it? run npm install starkzap and follow the 5-minute quickstart. for a full API walkthrough, check out the detailed developer guide.

real apps built with Starkzap

this isn't theoretical. real projects are shipping real products with this crypto SDK right now.

fitness apps earning bitcoin

we built a working demo integrating Starkzap with Strava. users complete fitness challenges and earn bitcoin rewards deposited directly to their wallet. the user never leaves the fitness app. they don't know they're on a blockchain. they just see "you earned 0.001 BTC for running 5km." (demo)

productivity apps with stake-to-focus

FocusTree (a Forest competitor) integrated Starkzap to let users lock tokens as a commitment device for focused work sessions. stake tokens, stay focused, get them back. lose focus, lose your stake. this onboarded 1M+ users onto Starknet through a productivity app that has nothing to do with crypto on the surface.

gaming in a day

Flappy Bird on Starknet was built in a single day using Starkzap. every pipe you pass writes to an onchain leaderboard. gasless gameplay via Cartridge Controller means players never think about transactions. they just play. there's a live demo you can try right now.

fintech and crypto payments

StarkSplit handles bill splitting in bitcoin with gasless settlements. RafflePunk runs fully transparent onchain raffles. Gift App lets users send tokens as gifts with yield via staking. these aren't toy projects. they're live applications solving real problems, built in days instead of months.

frequently asked questions

what is Starkzap?
Starkzap is an open-source TypeScript SDK built by StarkWare that lets developers add bitcoin, stablecoins, gasless transactions, DeFi features, and crypto payments to any web or mobile app. it runs on Starknet, an Ethereum layer 2 powered by zk-STARKs. one npm install replaces 5-10 separate blockchain libraries.

how do i install Starkzap?
run npm install starkzap in your project. the package is available on npm. for React Native mobile apps, also install @starkzap/native. full setup instructions are in the Starkzap documentation.

does Starkzap support bitcoin?
yes. Starkzap integrates strkBTC for native bitcoin on Starknet with shielded, private balances. developers can add bitcoin payments, rewards, and transfers to their app without managing bridges or wrapper tokens.

can i use Starkzap with React Native?
yes. Starkzap supports React Native and Expo for iOS and Android. install @starkzap/native alongside the core starkzap package and you get the same API, same social login onboarding, and same gasless transactions on mobile.

are Starkzap transactions gasless?
yes. by configuring the AVNU paymaster, all transactions can be fully sponsored so users never see or pay gas fees. the Starknet Foundation's Propulsion Program also offers up to $1M in gas subsidies for qualifying projects.

who built Starkzap?
Starkzap is built and maintained by StarkWare, the company behind Starknet. it is open-source under the MIT license, with the source code available on GitHub. as of march 2026, it has 500+ npm installs and is used by production apps like FocusTree, StarkSplit, and others.

start building

bring your app onchain in minutes. bring bitcoin to your users in minutes. that is not a future roadmap item. that is what you can do right now.

1. install: npm install starkzap
2. read the docs: docs.starknet.io/build/starkzap
3. check the examples: github.com/keep-starknet-strange/starkzap/tree/main/examples
4. join the debugging group: t.me/+I-Vt-_DcvecwNmY0
5. build something, deploy it, submit to awesome-starkzap

Starkzap is open-source (MIT license), built by StarkWare, and production-ready on Starknet mainnet and Sepolia testnet. 500+ npm installs, 80+ GitHub stars, and a growing list of live projects already in production.

your app is one npm install away from bitcoin. one npm install away from onchain. the only question is what you are going to build.

npm | github | docs | telegram