pip install sardis-sdk

from sardis_sdk import SardisClient

client = SardisClient(
    api_key: str,
    base_url: str = "https://api.sardis.sh",
    retry: RetryConfig | None = None,
    timeout: TimeoutConfig | None = None,
    pool: PoolConfig | None = None,
    log_level: LogLevel = LogLevel.BASIC,
)

with SardisClient(api_key="...") as client:
    agents = client.agents.list()

from sardis_sdk import AsyncSardisClient

client = AsyncSardisClient(
    api_key: str,
    base_url: str = "https://api.sardis.sh",
    retry: RetryConfig | None = None,
    timeout: TimeoutConfig | None = None,
    pool: PoolConfig | None = None,
    log_level: LogLevel = LogLevel.BASIC,
)

async with AsyncSardisClient(api_key="...") as client:
    agents = await client.agents.list()

from sardis_sdk import RetryConfig

config = RetryConfig(
    max_retries: int = 3,
    initial_delay: float = 0.5,
    max_delay: float = 30.0,
    exponential_base: float = 2.0,
    jitter: bool = True,
    retry_on_status: tuple[int, ...] = (429, 500, 502, 503, 504),
)

from sardis_sdk import TimeoutConfig

config = TimeoutConfig(
    connect: float = 10.0,  # Connection timeout in seconds
    read: float = 30.0,     # Read timeout in seconds
    write: float = 30.0,    # Write timeout in seconds
    pool: float = 10.0,     # Pool timeout in seconds
)

from sardis_sdk import PoolConfig

config = PoolConfig(
    max_connections: int = 100,
    max_keepalive_connections: int = 20,
    keepalive_expiry: float = 30.0,
)

agent = client.agents.create(
    name: str,
    description: str | None = None,
    spending_limits: dict[str, Any] | None = None,
    policy: dict[str, Any] | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Agent

agent = client.agents.get(
    agent_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Agent

agents = client.agents.list(
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Agent]

agent = client.agents.update(
    agent_id: str,
    name: str | None = None,
    description: str | None = None,
    spending_limits: dict[str, Any] | None = None,
    policy: dict[str, Any] | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Agent

client.agents.delete(
    agent_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> None

wallet = client.wallets.create(
    agent_id: str,
    mpc_provider: str = "turnkey",
    account_type: str = "mpc_v1",
    currency: str = "USDC",
    limit_per_tx: Decimal | None = None,
    limit_total: Decimal | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Wallet

wallet = client.wallets.get(
    wallet_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Wallet

wallets = client.wallets.list(
    agent_id: str | None = None,
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Wallet]

balance = client.wallets.get_balance(
    wallet_id: str,
    chain: str = "base",
    token: str = "USDC",
    timeout: float | TimeoutConfig | None = None,
) -> WalletBalance

tx = client.wallets.transfer(
    wallet_id: str,
    destination: str,
    amount: Decimal,
    token: str = "USDC",
    chain: str = "base",
    memo: str | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> WalletTransferResponse

result = client.payments.execute_mandate(
    mandate: dict[str, Any],
    wallet_id: str | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> ExecutePaymentResponse

result = client.payments.execute_ap2(
    bundle: dict[str, Any],
    wallet_id: str | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> ExecuteAP2Response

payment = client.payments.get(
    payment_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Payment

payments = client.payments.list(
    wallet_id: str | None = None,
    status: str | None = None,
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Payment]

hold = client.holds.create(
    wallet_id: str,
    amount: Decimal,
    token: str = "USDC",
    expires_in: int | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Hold

capture = client.holds.capture(
    hold_id: str,
    amount: Decimal | None = None,
    memo: str | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> CreateHoldResponse

client.holds.void(
    hold_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> None

hold = client.holds.get(
    hold_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Hold

holds = client.holds.list(
    wallet_id: str | None = None,
    status: str | None = None,
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Hold]

group = client.groups.create(
    name: str,
    budget: dict[str, str],
    merchant_policy: dict[str, Any] | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Group

group = client.groups.get(
    group_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Group

client.groups.add_agent(
    group_id: str,
    agent_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> None

client.groups.remove_agent(
    group_id: str,
    agent_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> None

spending = client.groups.get_spending(
    group_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> dict[str, Any]

parsed = client.policies.parse_nl(
    policy_text: str,
    timeout: float | TimeoutConfig | None = None,
) -> ParsedPolicy

check = client.policies.check(
    wallet_id: str,
    amount: Decimal,
    recipient: str,
    timeout: float | TimeoutConfig | None = None,
) -> PolicyCheckResponse

preview = client.policies.preview(
    policy: dict[str, Any],
    timeout: float | TimeoutConfig | None = None,
) -> PolicyPreviewResponse

card = client.cards.create(
    wallet_id: str,
    card_type: str = "virtual",
    spending_limits: dict[str, Any] | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Card

card = client.cards.get(
    card_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Card

cards = client.cards.list(
    wallet_id: str | None = None,
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Card]

account = client.treasury.get_account(
    account_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> FinancialAccount

balance = client.treasury.get_balance(
    account_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> TreasuryBalance

payment = client.treasury.create_payment(
    account_id: str,
    amount: Decimal,
    destination: str,
    method: str = "ach",
    timeout: float | TimeoutConfig | None = None,
) -> TreasuryPaymentResponse

webhook = client.webhooks.create(
    url: str,
    events: list[str],
    secret: str | None = None,
    metadata: dict[str, Any] | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> Webhook

webhook = client.webhooks.get(
    webhook_id: str,
    timeout: float | TimeoutConfig | None = None,
) -> Webhook

webhooks = client.webhooks.list(
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[Webhook]

entries = client.ledger.list(
    wallet_id: str | None = None,
    group_id: str | None = None,
    limit: int = 100,
    offset: int | None = None,
    timeout: float | TimeoutConfig | None = None,
) -> list[LedgerEntry]

class Agent(SardisModel):
    agent_id: str
    name: str
    description: str | None
    spending_limits: dict[str, Any] | None
    policy: dict[str, Any] | None
    is_active: bool
    created_at: datetime
    updated_at: datetime
    metadata: dict[str, Any] | None

class Wallet(SardisModel):
    wallet_id: str
    agent_id: str
    mpc_provider: str
    account_type: str
    addresses: dict[str, str]
    currency: str
    limit_per_tx: Decimal
    limit_total: Decimal
    is_active: bool
    created_at: datetime
    updated_at: datetime

class WalletBalance(SardisModel):
    wallet_id: str
    chain: str
    token: str
    balance: Decimal
    address: str

class Payment(SardisModel):
    payment_id: str
    wallet_id: str
    amount: Decimal
    token: str
    status: PaymentStatus
    tx_hash: str | None
    created_at: datetime
    updated_at: datetime

class Hold(SardisModel):
    hold_id: str
    wallet_id: str
    amount: Decimal
    token: str
    status: HoldStatus
    expires_at: datetime | None
    captured_amount: Decimal | None
    created_at: datetime
    updated_at: datetime

class Card(SardisModel):
    card_id: str
    wallet_id: str
    card_type: str
    last_four: str
    status: str
    spending_limits: dict[str, Any] | None
    created_at: datetime
    updated_at: datetime

from sardis_sdk import Chain

Chain.BASE          # "base"
Chain.ETHEREUM      # "ethereum"
Chain.POLYGON       # "polygon"
Chain.ARBITRUM      # "arbitrum"
Chain.OPTIMISM      # "optimism"
Chain.BASE_SEPOLIA  # "base_sepolia"

from sardis_sdk import Token

Token.USDC   # "USDC"
Token.USDT   # "USDT"
Token.EURC   # "EURC"
Token.PYUSD  # "PYUSD"

from sardis_sdk import MPCProvider

MPCProvider.TURNKEY     # "turnkey"
MPCProvider.FIREBLOCKS  # "fireblocks"
MPCProvider.LOCAL       # "local"

from sardis_sdk import PaymentStatus

PaymentStatus.PENDING
PaymentStatus.PROCESSING
PaymentStatus.COMPLETED
PaymentStatus.FAILED
PaymentStatus.CANCELLED

from sardis_sdk import HoldStatus

HoldStatus.ACTIVE
HoldStatus.CAPTURED
HoldStatus.VOIDED
HoldStatus.EXPIRED

from sardis_sdk import Page

page = client.agents.list_page(limit=100, offset=0)

for agent in page.items:
    print(agent.name)

if page.has_more:
    next_page = client.agents.list_page(limit=100, offset=page.next_offset)

from sardis_sdk import AsyncPaginator

async for agent in AsyncPaginator(
    client.agents.list,
    limit=100
):
    print(agent.name)

from sardis_sdk import bulk_execute_sync, BulkConfig

operations = [
    ("wallets.get", {"wallet_id": f"wallet_{i}"})
    for i in range(100)
]

result = bulk_execute_sync(
    client,
    operations,
    config=BulkConfig(
        max_concurrency=10,
        stop_on_error=False,
    )
)

print(f"Success: {result.summary.success_count}")
print(f"Failed: {result.summary.failure_count}")

from sardis_sdk import bulk_execute_async, BulkConfig

result = await bulk_execute_async(
    client,
    operations,
    config=BulkConfig(
        max_concurrency=10,
        stop_on_error=False,
    )
)