SDK quickstart

Use the Python or Go SDK to allocate a real Android phone, inspect its screen, and save a screenshot. Choose a language once and every code group on this page will follow your selection.

Before you start

An Axilio API key: open API Keys for your organization. See Authentication for details.
A dedicated phone ID: open Phones and choose an idle phone, or run axilio phones list. Replace ph_123 below with its ID.

Python SDK
Go SDK

Install Python 3.10 or newer.

1. Install the SDK

Python SDK
Go SDK

pip install axilio

On Windows, run py -m pip install axilio if pip is not on your PATH.

mkdir axilio-quickstart
cd axilio-quickstart
go mod init example.com/axilio-quickstart
go get github.com/axilioai/platform-go@latest

2. Set your API key

export AXILIO_API_KEY=axl_your_key_here

$env:AXILIO_API_KEY = "axl_your_key_here"

The variable lasts for the current terminal. Keep the key out of source control. Use your platform’s secret manager in CI and deployed services.

3. Inspect a phone

Python SDK
Go SDK

Client authenticates requests and exposes the platform’s resource groups. client.session() allocates a phone, connects a driver, and releases the phone when the block exits, including when the code raises an exception.Save this as quickstart.py:

from pathlib import Path

from axilio.platform import Client

client = Client()

# The context manager allocates a phone and releases it on every exit path.
with client.session("android", phone_id="ph_123") as driver:
    screen = driver.observe()
    print(f"Found {len(screen.texts)} text regions and {len(screen.icons)} icons")

    Path("screen.png").write_bytes(driver.screenshot())
    print("Saved screen.png")

The Go client exposes the same platform resources through typed services. This example allocates the phone explicitly and uses deferred cleanup to close the driver and release the phone on every return path.Save this as main.go:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"

    platformgo "github.com/axilioai/platform-go"
    "github.com/axilioai/platform-go/client"
    "github.com/axilioai/platform-go/drivers/mobile"
    "github.com/axilioai/platform-go/option"
)

func main() {
    if err := run(); err != nil {
        log.Fatal(err)
    }
}

func run() error {
    apiKey := os.Getenv("AXILIO_API_KEY")
    if apiKey == "" {
        return errors.New("AXILIO_API_KEY is not set")
    }

    ctx := context.Background()
    c := client.NewClient(option.WithAPIKey(apiKey))

    session, err := c.Phones.Allocate(ctx, &platformgo.PhoneAllocateRequest{
        PhoneType: platformgo.PhoneAllocateRequestPhoneTypeAndroid,
        PhoneID:   platformgo.String("ph_123"),
    })
    if err != nil {
        return fmt.Errorf("allocate phone: %w", err)
    }
    defer func() {
        if _, err := c.Phones.Deallocate(context.Background(), &platformgo.PhonesDeallocateRequest{
            PhoneID: session.PhoneID,
        }); err != nil {
            log.Printf("release phone: %v", err)
        }
    }()

    if session.ControlURL == nil {
        return errors.New("allocation returned no control URL")
    }

    driver := mobile.ConnectRemote(*session.ControlURL)
    defer func() { _ = driver.Close() }()

    screen, err := driver.Observe()
    if err != nil {
        return fmt.Errorf("observe screen: %w", err)
    }
    fmt.Printf("Found %d text regions and %d icons\n", len(screen.Texts), len(screen.Icons))

    png, err := driver.Screenshot()
    if err != nil {
        return fmt.Errorf("capture screenshot: %w", err)
    }
    if err := os.WriteFile("screen.png", png, 0o600); err != nil {
        return fmt.Errorf("save screenshot: %w", err)
    }
    fmt.Println("Saved screen.png")
    return nil
}

Use the same client to manage phones, workflows, runs, files, usage, billing, organizations, and API keys. Use the CLI when you prefer the equivalent operations in a terminal, or use the REST API when you need direct HTTP access.

4. Run it

Python SDK
Go SDK

python quickstart.py

On Windows, use py quickstart.py if python is not on your PATH.

go run .

You now have a complete allocation lifecycle: authenticate, reserve a phone, connect a mobile driver, observe the screen, save a screenshot, and release the phone on normal and error exits.

Prefer a terminal workflow? Follow the separate CLI guide. The CLI can allocate and drive a phone without an SDK project.

Next steps

Control a phone

Find screen elements and tap, type, swipe, or wait for them.

Phones and Sessions

Choose phones and understand allocation behavior.

Python SDK on GitHub

Browse the Python client, mobile driver, and examples.

Go SDK on GitHub

Browse the Go client, mobile driver, and package reference.

Get Started

Phones and Sessions

Workflows and Runs

Files

Observability

Telemetry

Usage

Billing

Organization

Reference

SDK quickstart

Before you start

1. Install the SDK

2. Set your API key

3. Inspect a phone

4. Run it

Next steps

Control a phone

Phones and Sessions

Python SDK on GitHub

Go SDK on GitHub

​Before you start

​1. Install the SDK

​2. Set your API key

​3. Inspect a phone

​4. Run it

​Next steps

Control a phone

Phones and Sessions

Python SDK on GitHub

Go SDK on GitHub

Before you start

1. Install the SDK

2. Set your API key

3. Inspect a phone

4. Run it

Next steps