DEV Community: Akashneelesh

Bring your app onchain in minutes through Starkzap

Akashneelesh — Tue, 24 Mar 2026 15:21:10 +0000

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.

install: npm install starkzap
read the docs: docs.starknet.io/build/starkzap
check the examples: github.com/keep-starknet-strange/starkzap/tree/main/examples
join the debugging group: t.me/+I-Vt-_DcvecwNmY0
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

Bring Bitcoin to your app now in minutes

Akashneelesh — Tue, 24 Feb 2026 14:27:59 +0000

You've thought about adding Bitcoin. Here's why you haven't done it yet.

Every time you look into adding Bitcoin to your app, you hit the same wall: wallets, private keys, gas fees, node infrastructure, security audits. Suddenly it's a 6-month project that requires hiring specialists.

It doesn't have to be.

We built this so you don't have to

Starkzap is an open-source TypeScript SDK that lets any application (web app, mobile app, backend service) integrate Bitcoin with no blockchain experience required.

npm install starkzap

That's your starting point. From there, you get:

Gasless transactions. Built-in paymaster means your users never pay network fees.
Social login. Google, Apple, email, passkeys. No seed phrases, no "write down these 12 words."
Token transfers. BTC, USDC, ETH, and 50+ tokens. Single recipient or batch.
Bitcoin staking. Real yield for your users, one line of code.
Works everywhere. Web, React Native, Node.js. Same API across all platforms.

Your users never see anything unfamiliar. No wallet popups. No confirmation dialogs with hex strings. No gas tokens. They just see your app, and it works.

What does this actually look like?

Here's what "15 minutes" means. Not in theory. In code.

1. Set up the SDK (30 seconds)

import { StarkSDK } from "starkzap";

const sdk = new StarkSDK({
  network: "mainnet",
  paymaster: { nodeUrl: "/api/paymaster" },
});

Done. Your app now has a payment backend.

2. Let users sign in with email (2 minutes)

No new login flow for your users to learn. They enter their email, get a one-time code, and they're in. Behind the scenes, they now have a wallet, but they don't need to know that.

const { wallet } = await sdk.onboard({
  strategy: OnboardStrategy.Privy,
  feeMode: "sponsored",
  privy: {
    resolve: async () => ({
      walletId: user.walletId,
      publicKey: user.publicKey,
      serverUrl: "/api/wallet/sign",
    }),
  },
});

Or if you prefer social login (Google, Apple, passkeys):

const { wallet } = await sdk.onboard({
  strategy: OnboardStrategy.Cartridge,
  feeMode: "user_pays",
});

Either way, wallet is the same object. Your downstream code doesn't change.

3. Send Bitcoin (1 minute)

import { Amount, fromAddress, mainnetTokens } from "starkzap";

const tx = await wallet.transfer(mainnetTokens.WBTC, [
  { to: fromAddress(recipientAddress), amount: Amount.parse("0.01", mainnetTokens.WBTC) },
]);

await tx.wait();

That's a confirmed Bitcoin transfer. Three lines. The user clicked "Send," saw a success message, and moved on with their day.

4. Let users earn yield on their Bitcoin (2 minutes)

Your users are holding Bitcoin in your app. Instead of it sitting there, they can earn yield on it, and you can offer this with almost no code:

// Find available staking pools
const pools = await sdk.getStakerPools(validatorAddress);

// Stake Bitcoin into a pool
const tx = await wallet.enterPool(pools[0].poolContract, Amount.parse("0.05", WBTC));
await tx.wait();

// Check how much they've earned
const position = await wallet.getPoolPosition(pools[0].poolContract);
console.log(`Earning: ${position.rewards.toFormatted()}`);

// Claim rewards whenever they want
await wallet.claimPoolRewards(pools[0].poolContract);

Your app now has a savings product. Users deposit, earn yield, withdraw whenever they want. A traditional fintech team would spend months building this with banking partners.

5. Batch payments (1 minute)

Need to send payments to multiple people at once? Payroll, splits, rewards distribution. One call:

const tx = await wallet.transfer(mainnetTokens.USDC, [
  { to: fromAddress(alice), amount: Amount.parse("500", mainnetTokens.USDC) },
  { to: fromAddress(bob), amount: Amount.parse("300", mainnetTokens.USDC) },
  { to: fromAddress(carol), amount: Amount.parse("200", mainnetTokens.USDC) },
]);

Three payments, one transaction, sub-cent fees. Compare that to three separate bank transfers with ACH delays and $25 wire fees.

What your users see vs. what actually happens

Here's the user experience:

What the user sees	What's actually happening
"Enter your email"	A secure wallet is created server-side
"Send $50 to Sarah"	An on-chain token transfer executes in ~500 ms
"Earn 5% on your balance"	Delegation staking on a validator with audited contracts
"Withdraw anytime"	Unstaking + transfer back to user's wallet
"No fees"	A paymaster sponsors the transaction cost

There is no moment where your user thinks "this is crypto." They think "this is a really good app."

4+ tokens, ready to go

Starkzap ships with presets for every major token. No contract addresses to look up, no ABI files to import:

import { mainnetTokens } from "Starkzap";

mainnetTokens.WBTC    // Bitcoin
mainnetTokens.ETH     // Ether
mainnetTokens.USDC    // USD Coin
mainnetTokens.STRK    // Starknet token

Each token comes with its name, symbol, decimal precision, and logo. Balance queries are one line:

const balance = await wallet.balanceOf(mainnetTokens.WBTC);
console.log(balance.toFormatted()); // "0.5 WBTC"

The Amount class handles all the decimal math so you never accidentally send 100x the intended amount. (This has actually cost real companies real money.)

Why this beats traditional payment rails

If you're building a product that moves money, here's what you're probably dealing with today:

Traditional rails	With Starkzap
3-5 business days for ACH	~2 seconds to confirmation
$25+ wire fees	Sub-cent (or zero with paymaster)
US-only or region-locked	Global by default
Bank partnerships and compliance vendors	`npm install starkzap`
Separate savings/yield requires banking license	Built-in staking, no license needed
Hours to integrate Stripe/Plaid/etc	15 minutes to first transaction

You don't have to replace your entire payment stack. This gives you an option that's faster, cheaper, and global, and you can add it in an afternoon.

Who is this for?

Fintech apps that want Bitcoin savings, cross-border payments, or multi-currency wallets without building from scratch.

Marketplaces that need escrow, instant settlement, and multi-party payment splits in a single transaction.

Creator platforms where fans tip, subscribe, or pay creators directly. Batch payouts to multiple creators at once.

Rewards and loyalty apps that issue tokens, let users trade or stake their rewards, or offer yield on accumulated points.

Remittance products that send USDC across borders for fractions of a cent. Recipients cash out locally.

Gaming and entertainment apps with in-app currency that has real value, instant transfers between players, and yield on idle balances.

Any app with a "wallet" or "balance" feature. If your users hold any form of value in your app, Starkzap lets that value do more.

The stack under the hood (you don't need to touch it)

Everything runs on production infrastructure, fully abstracted:

Privy handles wallet infrastructure. Creates and manages wallets server-side. Users authenticate with email or social login. No private keys in the browser.
AVNU is the paymaster service. Sponsors transaction fees so your users pay nothing. Covered by default.
Cartridge provides session-based wallets with social login. Pre-approved transaction types mean zero popups during normal usage.

You don't configure any of this manually. The SDK handles it. You call functions, your users see results.

Growth funding up to $1,000,000

For apps that ship and show traction, there's a path to grants and investment:

Early-stage builders get access to technical support and ecosystem resources
Apps that demonstrate real users and growth can apply for grants up to $1,000,000
The funding covers infrastructure costs, marketing, and development to help you go from prototype to product

If you build something real on Starkzap and users love it, there's funding to help you grow it.

$3,000 bounty, open for the next 2 weeks

Want to get started right now? There's money on the table.

Build a prototype using Starkzap and submit it:

$1,500 for the best overall build
$1,000 for the runner up
$500 for the most creative integration

To enter: Build your app, then submit a PR at github.com/keep-starknet-strange/awesome-Starkzap

The quickstart takes about 15 minutes. There are working example apps for web, mobile, and server in the repo. Fork one and make it yours.

Get started now

The SDK is open-source and MIT-licensed.

Source code and quickstart: github.com/keep-starknet-strange/x

Projects built with Starkzap: github.com/keep-starknet-strange/awesome-Starkzap

npm install starkzap

Fifteen minutes from now, your app could support Bitcoin.