Quickstart

This guide will help you create your first smart account using the Squads API. For a complete overview of the API capabilities, see the API Introduction.

Prerequisites

Before you begin, make sure you have:

A Squads API key (get one here)
An Ed25519 keypair for signing transactions (learn more about signing)
A supported token for paying fees (USDC or SOL) (fee documentation)

Making API Requests

All requests should be made to the base URL: https://developer-api.squads.so Include your API key and network in the request headers of every request:

Authorization: Bearer YOUR_API_KEY
x-squad-network: devnet // or 'mainnet' for production

Create your first smart account

Create a basic smart account with a single signer. For more details about smart account creation and management, see the Create Smart Account documentation.

const response = await fetch(
  "https://developer-api.squads.so/api/v0/smart_account/transaction/create",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "x-squad-network": "devnet",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      smart_account_signers: [
        {
          address: "YOUR_WALLET_ADDRESS",
          permissions: ["CAN_INITIATE", "CAN_VOTE", "CAN_EXECUTE"],
        },
      ],
      threshold: 1,
    }),
  }
);

const { smart_account_address } = await response.json();
console.log(`Smart Account created: ${smart_account_address}`);

That’s it! Your smart account is ready to use immediately. No transaction submission or fee payment required. You can later add more signers or set up spending limits as needed.

Create a token transfer

Let’s create a token transfer transaction using your new smart account. We’ll break this down into steps:

1. Set up the transfer instruction

First, import the required dependencies and create the token transfer instruction:

import { createTransferInstruction } from "@solana/spl-token";
import {
  Connection,
  PublicKey,
  TransactionMessage,
  VersionedTransaction
} from "@solana/web3.js";

// Initialize connection to Solana
const connection = new Connection("https://api.devnet.solana.com");

// Create the token transfer instruction
const transferInstruction = createTransferInstruction(
  new PublicKey("SOURCE_TOKEN_ACCOUNT"),    // The smart account's token account
  new PublicKey("DESTINATION_TOKEN_ACCOUNT"),
  new PublicKey(smart_account_address),     // The smart account is the authority
  1000000n                                  // Amount (e.g., 1 USDC)
);

2. Create a versioned transaction

Next, create a V0 transaction message with the latest blockhash:

// Get the latest blockhash
const latestBlockhash = await connection.getLatestBlockhash();

// Create a V0 transaction message
const message = new TransactionMessage({
  payerKey: new PublicKey(smart_account_address),
  recentBlockhash: latestBlockhash.blockhash,
  instructions: [transferInstruction]
}).compileToV0Message();

// Create and serialize the transaction
const transaction = new VersionedTransaction(message);
const serializedTransaction = Buffer.from(
  transaction.serialize()
).toString('base64');

3. Prepare the transaction

Send the transaction to the Squads API for preparation. This step will:

Add the necessary program instructions
Configure fee payment
Return the prepared transaction and fee details

const prepareResponse = await fetch(
  "https://developer-api.squads.so/api/v0/smart_account/transaction/prepare",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "x-squad-network": "devnet",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      smart_account_address,
      transaction: serializedTransaction,
      transaction_signers: ["YOUR_WALLET_ADDRESS"],
      fee_config: {
        currency: "usdc",        // Choose 'usdc' or 'sol'
        payer_address: "YOUR_FEE_PAYER_ADDRESS",
      },
    }),
  }
);

// Get the prepared transaction and fee information
const { transaction: preparedTransaction, fee } = await prepareResponse.json();

// Log the fee details
console.log(
  `Transaction prepared! Fee: ${fee.amount_decimal} ${fee.currency.toUpperCase()}`
);
console.log(
  `Fee in SOL: ${fee.sol_equivalent.amount_decimal} SOL`
);

4. Sign and submit the transaction

Finally, sign the prepared transaction with your wallet and submit it to Solana:

// Decode the prepared transaction
const decodedTransaction = VersionedTransaction.deserialize(
  Buffer.from(preparedTransaction, "base64")
);

// Sign with your wallet
decodedTransaction.sign([wallet]);

// Submit to Solana
const signature = await connection.sendRawTransaction(
  decodedTransaction.serialize()
);
console.log(`Transaction sent: ${signature}`);

// Wait for confirmation
const confirmation = await connection.confirmTransaction({
  signature,
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
});
console.log("Transfer complete!");

Each step builds on the previous one to create a complete token transfer flow. The Squads API handles the complexity of smart account execution, allowing you to focus on building your application logic.

Introduction

Core Concepts

Getting Started

Prerequisites

Making API Requests

Create your first smart account

Create a token transfer

1. Set up the transfer instruction

2. Create a versioned transaction

3. Prepare the transaction

4. Sign and submit the transaction

Next steps

Add Spending Limits

Explore the API

​Prerequisites

​Making API Requests

​Create your first smart account

​Create a token transfer

​1. Set up the transfer instruction

​2. Create a versioned transaction

​3. Prepare the transaction

​4. Sign and submit the transaction

​Next steps

Add Spending Limits

Explore the API

Prerequisites

Making API Requests

Create your first smart account

Create a token transfer

1. Set up the transfer instruction

2. Create a versioned transaction

3. Prepare the transaction

4. Sign and submit the transaction

Next steps