What is RobotActions Device Farm?

RobotActions Device Farm is a cloud testing platform that gives you real Android and iOS devices, Apple TV and Google TV boxes, and real browsers, in our cloud. Reach them from your browser, drive them with Selenium, Appium, Playwright or WebdriverIO, or let an AI agent drive them over MCP.

How many devices can I test on simultaneously?

Your concurrency is simply the number of devices on your plan: buy 11 devices and you can run 11 sessions at once. Sessions and test minutes on those devices are unlimited. A device is yours alone for the session and goes back to the pool when you release it; every device is restored to a clean state overnight. Enterprise plans get a dedicated host and devices that keep their state.

Do you provide real devices or emulators?

Real physical devices, always — no emulators and no simulators. They behave differently from the hardware your users actually hold, which is the whole reason to use a device farm.

What integrations do you support?

RobotActions works with Jenkins, GitHub Actions, GitLab CI/CD and other CI providers, and with Selenium, Appium, Playwright and WebdriverIO. Over MCP, an AI agent can also reach Jira, TestRail and Azure DevOps — reading stories and acceptance criteria, updating test cases and filing defects. Our API allows custom integrations with your existing workflow.

Can I record my test sessions?

Yes, all test sessions can be recorded with our video playback feature. This allows you to review test executions, analyze failures, and share recordings with your team for collaborative debugging.

Can I test geo-restricted applications?

Yes for location itself — you can emulate the device GPS position and mock API responses, so location-based features in your own app are fully testable on a real device. One limit worth stating plainly: we do not control the IP address your traffic leaves from, so a restriction a third party enforces by source IP is out of scope today.

Yes. Apple TV (tvOS) and Google TV / Android TV boxes are in the device list alongside phones, at the same per-device price. Live control gives you a full remote in the browser — d-pad, OK, back, home, play/pause, volume, power, and typing straight into the TV — next to a live stream with audio as well as video, so you can check audio and playback, not just the screen. AI agents drive them over MCP, and Appium suites run on them the same way they run on a phone.

Do live sessions include audio?

Yes. Live sessions stream audio as well as video on every device type — Android phones and tablets, iPhone and iPad, Apple TV, Google TV / Android TV, and desktop browsers. Test video and music playback, notification sounds, in-app audio cues and media controls with the device's real audio, not just the screen.

Can I test with VoiceOver or TalkBack on a real device?

Yes, on both platforms: VoiceOver on iPhone and iPad, TalkBack on Android. Turn the screen reader on from the panel in a live session and drive it with Previous, Next, Activate, Back, Home and Read All, or with the arrow keys and Enter (plus the rotor on iOS). No gestures to memorise. The panel shows the exact text the screen reader speaks for each element as a running transcript, and the spoken output streams to your computer with the rest of the device audio. Missing labels, a wrong reading order and unhelpful announcements show up in writing, not only in the audio. Switch the device language, or only the app's, to check it in every language your app ships in.

Can I run accessibility audits on real devices?

Yes. Run an accessibility scan on a real iPhone, iPad or Android device and get an audit report of what it finds — from the console, or let your AI agent run the same scan over MCP and file what it finds in Jira, Azure DevOps or TestRail. Pair it with the screen-reader panel (VoiceOver or TalkBack) to check how the screen actually reads, and with device or app language switching to repeat the check in every language you ship.

Real Device Testing in Your CI/CD Pipeline

Your pipeline is green on an emulator and red in the store. Point the same Appium, Selenium, Playwright or WebdriverIO suite at real iPhones and Android phones from GitHub Actions, Jenkins or GitLab CI. Concurrency is the number of devices you buy, with unlimited minutes.

A Published GitHub Action

robotactions-device-cloud is live on the GitHub Marketplace. Pass an API token from an encrypted secret and it resolves the grid endpoint, masks the token in logs and records the suite and release against each session.

Per Device, Not Per Parallel Slot

Pricing is flat per device per month, from $125 for automation. Each device you buy is one simultaneous run. We do not bill per minute, so a long nightly regression costs the same as a short one.

The Frameworks You Already Run

Appium, Selenium, Playwright and WebdriverIO connect over a token-authenticated endpoint. Jenkins and GitLab CI need only the same environment variable and header.

Evidence When a Build Goes Red

Every session is recorded with device logs, and crashes are captured and grouped. Open the failed session instead of re-running it to guess. An AI agent can read the run and diagnose why it failed.

Add Real Devices to a Pipeline

Keep the token in your CI secret store. Your framework sends it to the grid as a Bearer header.

.github/workflows/mobile-e2e.yml

name: Mobile E2E
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci

      - name: Connect to RobotActions
        id: ra
        uses: RobotActions/[email protected]
        with:
          api-token: ${{ secrets.RA_API_TOKEN }}
          test-suite: ${{ github.workflow }} run ${{ github.run_number }}
          release-id: ${{ github.sha }}

      - run: npm run test:e2e
        env:
          GRID_URL: ${{ steps.ra.outputs.grid-url }}

Run Your Next Build on Real Devices

The free tier needs no credit card. Point one suite at one device and compare it with your emulator run.