AppKit: the SDK for Mini Apps and dApps on TON in 2026

AppKit is the new frontend SDK from TON Foundation, published as part of TON Toolset in 2026. It replaces the fragmented tonweb / ton-core / tonconnect-sdk stack with a unified high-level API for Mini App and dApp development.

Let’s break down what’s inside, how it simplifies the work, and where to start.

What’s in AppKit

The base @ton/appkit package contains:

• TON Connect for wallet connection (the original tonconnect-sdk under the hood).
• Typed transaction builders — TypeScript-typed constructors instead of raw cells.
• Asset reads — TON and jetton balances in one line.
• DNS resolution — .ton/.t.me addresses → canonical addresses.
• DEX quotes — STON.fi/DeDust quotes right from the SDK, no separate calls.
• Staking helpers — deposit/withdraw to Tonstakers and peers via ready methods.
• Gas-station integration — gasless transfers via Battery and similar providers.

@ton/appkit-react on top adds:

• <TonConnect /> — a ready wallet connection component.
• <TonBalance /> — balance display.
• <TonTransfer /> — a button with built-in send logic.
• Hooks — useWallet(), useBalance(), useTransfer(), useDexQuote().
• Provider — <AppKitProvider> for context.

Minimal example

The shortest Mini App with wallet connect and a transfer:

import { AppKitProvider, TonConnect, useWallet, useTransfer } from '@ton/appkit-react';

function App() {
  return (
    <AppKitProvider manifestUrl="https://your-app.com/tonconnect-manifest.json">
      <Header />
      <SendForm />
    </AppKitProvider>
  );
}

function Header() {
  return <TonConnect />;
}

function SendForm() {
  const { isConnected, address } = useWallet();
  const { send, isLoading } = useTransfer();

  if (!isConnected) return <p>Connect wallet first</p>;

  const onClick = async () => {
    await send({
      to: 'recipient.ton',
      amount: '1.5 TON',
    });
  };

  return <button onClick={onClick} disabled={isLoading}>Send 1.5 TON</button>;
}

What’s happening:

• <TonConnect /> renders the “Connect wallet” button and handles the whole connection flow.
• useWallet() returns connection state and address.
• useTransfer() gives you a send method with typed params: {to, amount} — no raw cells.
• 'recipient.ton' AppKit resolves to a canonical address via DNS.
• '1.5 TON' AppKit parses into nanoTON automatically.

That’s 20 lines vs ~150-200 with the old stack (TonConnect provider + manual cells serialisation + address parsing + amount math).

Typed transactions: the main win

Old way to send a transfer (ton-core):

import { Address, beginCell, toNano } from '@ton/core';

const body = beginCell()
  .storeUint(0, 32)
  .storeStringTail(comment)
  .endCell();

const tx = {
  validUntil: Math.floor(Date.now() / 1000) + 60,
  messages: [
    {
      address: Address.parse(to).toString(),
      amount: toNano(amount).toString(),
      payload: body.toBoc().toString('base64'),
    },
  ],
};
await tonConnectUI.sendTransaction(tx);

In AppKit:

import { useTransfer } from '@ton/appkit-react';

const { send } = useTransfer();
await send({ to: 'friend.ton', amount: '1.5 TON', comment: 'Hi' });

The diff:

• No hand-assembled cell for the body.
• No address transformation (DNS works directly).
• No toNano (AppKit parses “1.5 TON”).
• No manual BoC + base64 serialisation.
• No validUntil math — AppKit sets a default.

DEX quotes in one line

import { useDexQuote } from '@ton/appkit-react';

const { quote } = useDexQuote({
  from: 'TON',
  to: 'USDT',
  amount: '10 TON',
});
// quote: { expectedOutput: '21.42 USDT', priceImpact: 0.03, route: 'STON.fi' }

Under the hood — calls to STON.fi and DeDust, picking the best route. No need to wire separate APIs.

DNS resolution

const { address } = useResolveDns('alice.ton');
// 'EQDxxx...'

Works for .ton, .t.me (telegram-username-dns subdomain), and old TON DNS contract styles.

Staking helpers

import { useStaking } from '@ton/appkit-react';

const { stake, unstake, balance, apy } = useStaking({ protocol: 'tonstakers' });
await stake({ amount: '10 TON' });
// stake → stTON in wallet, visible via useBalance.

Supports Tonstakers, Hipo, Stakee. Each protocol implemented as a plugin, custom ones can be added.

Bundle size comparison

I measured a test Mini App that does: connect, balance, transfer, DEX quote.

Not a critical saving, but noticeable. The bigger win — in LoC and maintainability.

When to use AppKit, when not

Use:

• New Mini App or dApp — definitely AppKit.
• Existing Mini App, actively developed — incremental migration, 2-4 sprints.
• You want to minimise frontend boilerplate.

Don’t use (yet):

• Very non-standard scenarios where you need low-level cells (stay on ton-core).
• Legacy code in maintenance — don’t touch.
• Your framework isn’t JS (Python, Go) — AppKit is TypeScript-only for now.

What’s not covered

AppKit focuses on the frontend. Not included:

• Backend operations (for accepting payments — separate TON Pay SDK).
• Wallet-side TON Connect (for wallet builders — WalletKit).
• Indexing / analytics — TonAPI v3 or DeFiLlama.

What’s next

• Official docs: docs.ton.org/ecosystem/appkit/overview.
• GitHub: ton-connect/kit (shared monorepo for AppKit + WalletKit + MCP).
• NPM: @ton/appkit, @ton/appkit-react.

Building a Mini App in 2026 — start with AppKit. The lowest barrier to TON frontend the ecosystem has ever had. Full Toolset context — in our overview.