JavaScript / TypeScript

@solana/web3.js is the official JavaScript and TypeScript client for Solana, maintained by Solana Labs. Install it with npm install @solana/web3.js. It ships its own TypeScript type definitions, so RPC responses, PublicKey, Keypair, and transaction types are fully typed out of the box, and the same package runs in Node.js and in the browser — making it the natural choice for both backends and web wallets.

The Connection object is the entry point for every RPC call you make to Solana. Its second argument sets the default commitment (processed, confirmed, or finalized) applied to reads, and passing a wsEndpoint alongside it enables WebSocket PubSub subscriptions over wss://solana.therpc.io/YOUR_API_KEY.

Connecting

Construct a Connection against the Solana HTTP endpoint https://solana.therpc.io/YOUR_API_KEY. A default commitment of confirmed suits most applications: it returns state a supermajority of the cluster has voted on, arriving in roughly a slot or two (slots are about 400ms) while still being safe to act on. From there getBalance returns lamports — divide by LAMPORTS_PER_SOL for SOL — and getAccountInfo returns the account's owner program, lamports, and data.

1import {
2  Connection,
3  PublicKey,
4  LAMPORTS_PER_SOL,
5} from '@solana/web3.js';
6 
7const connection = new Connection('https://solana.therpc.io/YOUR_API_KEY', 'confirmed');
8 
9// Get balance in SOL
10async function getBalance(address: string): Promise<number> {
11  const lamports = await connection.getBalance(new PublicKey(address));
12  return lamports / LAMPORTS_PER_SOL;
13}
14 
15// Read full account state
16async function getAccount(address: string) {
17  return connection.getAccountInfo(new PublicKey(address));
18}

Sending a Transaction

To move SOL, build a Transaction with a SystemProgram.transfer instruction. sendAndConfirmTransaction handles the busywork for you: it fetches a fresh blockhash from getLatestBlockhash (Solana transactions expire fast, so a recent blockhash is required), signs with the provided keypairs, broadcasts the transaction, and polls its status until it reaches confirmation before returning the signature.

1import {
2  Connection,
3  Keypair,
4  PublicKey,
5  SystemProgram,
6  Transaction,
7  sendAndConfirmTransaction,
8} from '@solana/web3.js';
9 
10const connection = new Connection('https://solana.therpc.io/YOUR_API_KEY', 'confirmed');
11 
12async function transfer(from: Keypair, to: string, lamports: number) {
13  const tx = new Transaction().add(
14    SystemProgram.transfer({
15      fromPubkey: from.publicKey,
16      toPubkey: new PublicKey(to),
17      lamports,
18    }),
19  );
20 
21  // sendAndConfirmTransaction fetches a blockhash and polls status for you
22  return sendAndConfirmTransaction(connection, tx, [from]);
23}

• GitHub: https://github.com/solana-labs/solana-web3.js
• Docs: https://solana-labs.github.io/solana-web3.js/
• Key features: the Connection RPC client, transaction building, Keypair and PublicKey helpers, WebSocket subscriptions, and SPL token support via the companion @solana/spl-token package.

WebSocket Subscriptions

Methods like onAccountChange, onLogs, and onSlotChange open a Solana PubSub stream over the wss://solana.therpc.io/YOUR_API_KEY endpoint, pushing updates as soon as the watched account, log, or slot advances — no polling required. Each returns a numeric subscription id; pass it to the matching remover (for example removeAccountChangeListener) to unsubscribe and free the server-side resources when you no longer need the stream.

1import { Connection, PublicKey } from '@solana/web3.js';
2 
3const connection = new Connection('https://solana.therpc.io/YOUR_API_KEY', {
4  commitment: 'confirmed',
5  wsEndpoint: 'wss://solana.therpc.io/YOUR_API_KEY',
6});
7 
8const subId = connection.onAccountChange(
9  new PublicKey('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM'),
10  (info, ctx) => console.log('slot', ctx.slot, 'lamports', info.lamports),
11  'confirmed',
12);
13 
14// await connection.removeAccountChangeListener(subId);

TypeScript Support

@solana/web3.js is written in TypeScript and bundles its own declaration files, so you get full typing without installing any @types/* packages. That means IDE autocompletion across the API, compile-time checking that catches mistakes like passing a string where a PublicKey is expected, and strongly typed RPC responses such as AccountInfo<Buffer> from getAccountInfo.

1import { Connection, PublicKey, AccountInfo } from '@solana/web3.js';
2 
3async function readOwner(
4  connection: Connection,
5  address: string,
6): Promise<string | null> {
7  const info: AccountInfo<Buffer> | null = await connection.getAccountInfo(
8    new PublicKey(address),
9  );
10  return info ? info.owner.toBase58() : null;
11}