Solana Python API

0.36.11 · active · verified Mon Apr 13

Solana.py is the official Python SDK for interacting with the Solana blockchain. It provides a robust API for building transactions, interacting with the Solana JSON RPC API, and working with the SPL Token Program. The library is actively maintained with frequent releases, often incorporating core types and high-performance components from the `solders` library.

Warnings

breaking Starting with v0.36.0, support for legacy transaction formats has been removed. Users should migrate to `VersionedTransaction` and `MessageV0` from `solders.transaction` and `solders.message` respectively.
Fix: Rewrite transaction creation and signing logic to use `solders.transaction.VersionedTransaction` and `solders.message.MessageV0`. Refer to the latest Solana.py documentation or Cookbook for updated examples.
breaking Many core data types (e.g., `Keypair`, `Pubkey`, `Message`, `Transaction`) were migrated from `solana-py`'s internal modules to the `solders` library. Direct imports from `solana.keypair`, `solana.publickey`, or `solana.transaction` for these types are deprecated or will result in errors.
Fix: Update imports to use `solders` for core types (e.g., `from solders.keypair import Keypair`, `from solders.pubkey import Pubkey`, `from solders.message import MessageV0`). Ensure `solders` is installed alongside `solana`.
deprecated The entire `solana.transaction` module and its classes (e.g., `Transaction`, `Message`) are deprecated. Additionally, methods like `get_stake_activation` have been deprecated.
Fix: Migrate to `solders.transaction.VersionedTransaction` and `solders.message.MessageV0` for transaction construction. Replace deprecated RPC methods with their modern equivalents or alternative approaches.
gotcha The `BlockhashCache`, an experimental feature, was removed in v0.33.0 due to it being 'experimental and flawed' and a 'footgun because it broke a lot'.
Fix: Remove any reliance on `BlockhashCache`. Always fetch the latest blockhash directly using `client.get_latest_blockhash()` before constructing transactions.
gotcha When constructing transactions using `solders.transaction.Transaction` (especially older patterns) or `VersionedTransaction`, incorrect argument types or missing required arguments for the constructor are common, leading to `TypeError` or runtime errors like `argument 'payer': 'Hash' object cannot be converted to 'Pubkey'`.
Fix: Carefully review the `solders` and `solana-py` documentation for the exact constructor signatures for `Transaction` and `VersionedTransaction`. Ensure all required arguments (`from_keypairs`, `message`, `recent_blockhash`) are provided with the correct `solders` types (e.g., `Pubkey` for payer, `MessageV0` for message, `Hash` for blockhash).

Install

pip install solana solders Install solana-py and solders

Imports

AsyncClient
```
from solana.rpc.async_api import AsyncClient
```
AsyncClient is the recommended client for most modern applications due to Solana's high-throughput nature.
Keypair
```
from solders.keypair import Keypair
```
Core types like Keypair have been moved from `solana.keypair` to `solders.keypair` for improved performance and consistency across Solana Python SDKs.
Pubkey
```
from solders.pubkey import Pubkey
```
Core types like PublicKey have been moved from `solana.publickey` to `solders.pubkey`.
VersionedTransaction
```
from solders.transaction import VersionedTransaction
```
The `solana.transaction` module is deprecated. Use `solders.transaction` and `VersionedTransaction` for modern transaction formats.
MessageV0
```
from solders.message import MessageV0
```
The `solana.transaction.Message` class is deprecated. `solders.message.MessageV0` (or `Message`) is the current standard.

Quickstart

This quickstart demonstrates how to connect to the Solana Devnet using `AsyncClient` and fetch the SOL balance of a specified public key. It highlights the use of `solders.pubkey.Pubkey` and the asynchronous nature of `solana-py` interactions. Remember to replace the example public key with a valid one and set `SOLANA_RPC_URL` if not using the default devnet endpoint.

import asyncio
import os

from solders.pubkey import Pubkey
from solana.rpc.async_api import AsyncClient

async def get_sol_balance(public_key_str: str):
    """Fetches the SOL balance of a given public key."""
    # Use a devnet RPC endpoint. For production, consider using a dedicated provider.
    rpc_url = os.environ.get("SOLANA_RPC_URL", "https://api.devnet.solana.com")
    async with AsyncClient(rpc_url) as client:
        pubkey = Pubkey.from_string(public_key_str)
        try:
            response = await client.get_balance(pubkey)
            balance_lamports = response.value
            balance_sol = balance_lamports / 1_000_000_000 # 1 SOL = 1,000,000,000 lamports
            print(f"Account: {public_key_str}")
            print(f"Balance: {balance_sol} SOL ({balance_lamports} lamports)")
        except Exception as e:
            print(f"Error fetching balance: {e}")

if __name__ == "__main__":
    # Replace with a real Solana public key (e.g., from a test wallet)
    example_public_key = "5Q544fFztbO2Drj9yQ9C7M2f8L2rW3e3H5D2n6H6f8f8" # Example devnet address
    asyncio.run(get_sol_balance(example_public_key))

view raw JSON →