Allocate a phone

Start a session on any idle dedicated phone, or pass a phone_id to choose an exact device.

Start and release

Dashboard
CLI
Python SDK
Go SDK
REST API

Open Sessions and choose your organization.
Click Allocate A Phone.
Choose Use A Dedicated Phone, then select Any available or one exact idle phone.
Optionally add a session name, tags, or an idle timeout.
Click Allocate.
Click Release in the session list or Deallocate in the active session view when you finish.

axilio phones list
eval "$(axilio sessions start --phone-id ph_123 --export)"

# Release by session ID. Clear the shell selection only once the stop succeeds.
axilio sessions stop "$AXILIO_SESSION" --yes && unset AXILIO_SESSION

axilio phones list
axilio sessions start --phone-id ph_123 --export | Invoke-Expression

# Release by session ID. Clear the shell selection only once the stop succeeds.
axilio sessions stop $env:AXILIO_SESSION --yes
if ($LASTEXITCODE -eq 0) { Remove-Item Env:AXILIO_SESSION }

--export prints a shell assignment that pins later CLI commands to the new session. If you do not need that environment variable, run axilio sessions start --phone-id ph_123 and retain the returned session ID for cleanup.

Prefer the context manager because it releases the phone on every exit path:

from axilio.platform import Client

client = Client()

with client.session("android", phone_id="ph_123") as driver:
    print(driver.observe())

Manage the lifetime directly only when it must outlive a with block:

allocation = client.phones.allocate(
    phone_type="android",
    pool="dedicated",
)
try:
    print(allocation.phone_id, allocation.session_id)
    # Connect to allocation.control_url and drive the phone.
finally:
    client.phones.deallocate(allocation.phone_id)

pool="dedicated" chooses any idle rented phone. Add phone_id="ph_123" to pin the request to an exact phone.

allocation, err := api.Phones.Allocate(ctx, &platformgo.PhoneAllocateRequest{
    PhoneType: platformgo.PhoneAllocateRequestPhoneTypeAndroid,
    Pool:      platformgo.PhoneAllocateRequestPoolDedicated.Ptr(),
})
if err != nil {
    log.Fatal(err)
}
defer func() {
    if _, err := api.Phones.Deallocate(ctx, &platformgo.PhonesDeallocateRequest{
        PhoneID: allocation.PhoneID,
    }); err != nil {
        log.Printf("release phone: %v", err)
    }
}()

PoolDedicated chooses any idle rented phone. Add PhoneID: platformgo.String("ph_123") to pin the request.

REST API References:

Allocate a phone: POST /phones:allocate
Release a phone: POST /phones/{phone_id}:deallocate

Examples use Bash. To run them in PowerShell, see Run the curl examples on Windows.

ALLOCATION=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url https://api.axilio.ai/api/v1/phones:allocate \
  --header "X-Axilio-Api-Key: $AXILIO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"phone_type":"android","pool":"dedicated"}')

PHONE_ID=$(printf '%s' "$ALLOCATION" | jq -r '.phone_id')
printf '%s\n' "$ALLOCATION" | jq

curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.axilio.ai/api/v1/phones/$PHONE_ID:deallocate" \
  --header "X-Axilio-Api-Key: $AXILIO_API_KEY"

The Dashboard, generated SDK allocation methods, and REST API support Any available dedicated selection. The CLI and Python client.session() helper use the exact-phone path shown above, so give them a dedicated phone_id.

Direct allocation is a lease. Release the phone when you finish so another session can use it. Dedicated-phone rental charges are separate from session lifetime.

Allocation options

The public API can also set:

name and tags to organize sessions
recording to enable or disable video
telemetry to enable or suppress both live and retained Telemetry for this directly allocated session
capture to add media produced on the phone to Files
live_view to configure the hosted viewer
ttl.idle_timeout_seconds to release an unattended phone
workflow_id to associate an explicitly allocated session with a workflow

Recording, Telemetry, file capture, and interactive token-authenticated live view default to enabled. A session name uses 1 to 64 letters, numbers, dots, hyphens, or underscores and must be unique among active sessions. An allocation accepts up to 50 tags; tag keys are limited to 40 UTF-8 bytes and values to 128 UTF-8 bytes. The Python client.session() helper intentionally exposes the common interactive path. Use client.phones.allocate() when you need the full option set.

Next steps

Discover phones

Find an idle dedicated phone ID.

Session lifecycle

Configure idle timeout and inspect active or completed sessions.

Live view

Watch or interact with an active phone.

Telemetry

Follow an active session and read its retained trace.

Get Started

Phones and Sessions

Workflows and Runs

Files

Observability

Telemetry

Usage

Billing

Organization

Reference

Allocate a phone

Start and release

Allocation options

Next steps

Discover phones

Session lifecycle

Live view

Telemetry

​Start and release

​Allocation options

​Next steps

Discover phones

Session lifecycle

Live view

Telemetry

Start and release

Allocation options

Next steps