Recordings

Screen recording is on by default. When enabled, Axilio records the phone’s screen and makes the MP4 available after the session ends and its upload finishes. Recordings are keyed by session_id, so the same lookup works for workflow runs and directly allocated sessions.

Configure recording

Recording is an allocation-time setting. Changing a workflow affects its future runs, not sessions that already started.

Dashboard
CLI
Python SDK
Go SDK
REST API

Configure one directly allocated session:

Open Sessions.
Click Allocate A Phone.
Expand advanced configuration.
Turn recording off if you do not want Axilio to capture the screen.
Click Allocate.

The Dashboard does not currently expose the workflow-level recording setting. Use the CLI when creating a workflow, or use an SDK or REST to update one.

Disable recording when you create a workflow:

axilio workflows create checkout-flow --recording=false

Confirm its current setting with axilio workflows get <workflow-id>. The CLI does not expose a recording flag on sessions start or an update command for an existing workflow.

Disable recording for one direct allocation:

from axilio.platform import Client

client = Client()
allocation = client.phones.allocate(
    phone_type="android",
    phone_id="ph_123",
    recording=False,
)

Disable recording for future runs of an existing workflow:

from axilio.platform import Client

client = Client()
client.workflows.update(
    "wf_123",
    recording=False,
)

package main

import (
    "context"
    "log"
    "os"

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

func main() {
    ctx := context.Background()
    api := client.NewClient(option.WithAPIKey(os.Getenv("AXILIO_API_KEY")))
    recordingOff := false

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

    if _, err := api.Workflows.Update(ctx, &platformgo.WorkflowUpdateRequest{
        WorkflowID: "wf_123",
        Recording:  &recordingOff,
    }); err != nil {
        log.Fatal(err)
    }
}

The allocation setting applies only to allocation.SessionID. The workflow update applies to future runs.

REST API References:

Allocate a phone: POST /phones:allocate
Update a workflow: PATCH /workflows/{workflow_id}

Disable recording for one direct allocation:Examples use Bash. To run them in PowerShell, see Run the curl examples on Windows.

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",
    "phone_id": "ph_123",
    "recording": false
  }'

Disable recording for future runs of an existing workflow:

curl --silent --show-error --fail-with-body \
  --request PATCH \
  --url https://api.axilio.ai/api/v1/workflows/wf_123 \
  --header "X-Axilio-Api-Key: $AXILIO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"recording":false}'

When recording is disabled, Axilio does not write a recording or rolling thumbnail for that session. Your organization’s data-retention policy can also prevent recordings from being created or make older recordings unavailable.

Replay or download a recording

Dashboard
CLI
Python SDK
Go SDK
REST API

Open Sessions.
Change the status filter if the completed session is not visible.
Select the session.
Play the recording on the left side of the SESSION VIEWER.

The Timeline and Console stay synchronized with playback. Select a timeline bar or console entry to seek to that point. The viewer shows a processing, expired, or unavailable state when no playable URL exists.

Look up the recording’s status and, when it is ready, a time-limited URL:

axilio sessions recording sess_123
axilio sessions recording sess_123 -o json

The lookup exits 0 for ready, pending, and expired, so a script can branch on the status field.Download the MP4. --wait polls while the recording is still processing (default timeout 10 minutes, exit status 5 when it elapses), and --force overwrites an existing file:

axilio sessions recording sess_123 --wait --out session.mp4

The file is written atomically, so an interrupted download never leaves a partial MP4 behind. A pending recording is refused without --wait; an expired recording cannot be downloaded and exits with not-found status 4. Run the lookup again instead of persisting a URL: returned URLs expire.

from pathlib import Path

import httpx

from axilio.platform import Client

client = Client()
recording = client.phones.session_recording("sess_123")

if recording.status != "ready" or not recording.url:
    raise RuntimeError(f"recording is {recording.status}")

with httpx.stream("GET", recording.url, follow_redirects=True) as response:
    response.raise_for_status()
    with Path("session.mp4").open("wb") as output:
        for chunk in response.iter_bytes():
            output.write(chunk)

package main

import (
    "context"
    "errors"
    "io"
    "log"
    "net/http"
    "os"

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

func main() {
    ctx := context.Background()
    api := client.NewClient(option.WithAPIKey(os.Getenv("AXILIO_API_KEY")))

    recording, err := api.Phones.SessionRecording(
        ctx,
        &platformgo.PhonesSessionRecordingRequest{SessionID: "sess_123"},
    )
    if err != nil {
        log.Fatal(err)
    }
    if recording.Status != platformgo.PhoneSessionRecordingResponseStatusReady ||
        recording.URL == nil {
        log.Fatal(errors.New("recording is not ready"))
    }

    response, err := http.Get(*recording.URL)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        log.Fatalf("download recording: %s", response.Status)
    }

    output, err := os.Create("session.mp4")
    if err != nil {
        log.Fatal(err)
    }
    defer output.Close()

    if _, err := io.Copy(output, response.Body); err != nil {
        log.Fatal(err)
    }
}

REST API References:

Get a session recording: GET /phones/sessions/{session_id}/recording

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

RECORDING=$(curl --silent --show-error --fail-with-body \
  --request GET \
  --url https://api.axilio.ai/api/v1/phones/sessions/sess_123/recording \
  --header "X-Axilio-Api-Key: $AXILIO_API_KEY")

STATUS=$(printf '%s' "$RECORDING" | jq -r '.status')
if [ "$STATUS" != "ready" ]; then
  printf 'recording is %s\n' "$STATUS" >&2
  exit 1
fi

RECORDING_URL=$(printf '%s' "$RECORDING" | jq -r '.url')
curl --silent --show-error --fail --location \
  "$RECORDING_URL" \
  --output session.mp4

Recording states

Status	Meaning
`ready`	`url` contains a time-limited playback link.
`pending`	No recording object is available. The session may still be active, its upload may still be processing, or recording may have been disabled.
`expired`	The recording is outside the organization’s retention window.

Only ready includes a URL. If you know recording was enabled and the session has completed, fetch the lookup again while its upload processes, or let axilio sessions recording <session-id> --wait poll for you. pending alone does not promise that a recording will appear.

Get Started

Phones and Sessions

Workflows and Runs

Files

Observability

Telemetry

Usage

Billing

Organization

Reference

Configure recording

Replay or download a recording

Recording states

Next steps

Telemetry dashboard

Live view

​Configure recording

​Replay or download a recording

​Recording states

​Next steps

Telemetry dashboard

Live view

Configure recording

Replay or download a recording

Recording states

Next steps