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.

RobotActions vs AWS Device Farm: When the Meter Is the Problem (2026)

Every minute you hold a phone in an AWS Device Farm tab costs you $0.17 — $10.20 an hour before you have run a single test — and if you are reproducing a bug on it, that number is sitting in the back of your head the whole time.

If you are AWS-native and your usage is bursty, Device Farm is a reasonable choice and this post says so. If your team touches real devices every day, the meter changes how people work, and that is the case for looking at something flat. Here is an honest comparison, with AWS's own published numbers.

TL;DR

Billing — Device Farm: $0.17 per device-minute, or an unlimited slot from $250/month. RobotActions: $25/device/month for live control plus MCP, $125/device/month with Appium/Selenium execution, unlimited sessions and minutes.
AI agents — Device Farm: no agent interface; the entry points are a test upload and an Appium endpoint. RobotActions: Claude, Cursor, or your own agent drives the device over MCP, included from the free tier.
Concurrency — Device Farm: default quota of 5 automation devices and 2 remote-access devices, raised by request. RobotActions: the devices on your plan, with no quota to file for.
Session length — Device Farm: hard 150-minute cap on runs and remote sessions. RobotActions: unlimited sessions; a live session holds a device for up to 30 minutes at a time and you take it straight back if it is still free.
Region — Device Farm: us-west-2 (Oregon) only. RobotActions: hosted, reached from a browser wherever you are.
Frameworks — Device Farm: Appium, Espresso/Instrumentation, XCTest. RobotActions: Appium, WebdriverIO, Selenium, Playwright, XCUITest, Espresso.
Where each wins — Device Farm: AWS-native pipelines with occasional, bursty usage. RobotActions: daily hands-on device work, and anything an AI agent is going to drive.

(AWS figures are from its pricing, FAQ and quotas pages at the time of writing. Verify before you decide — they change.)

Where Device Farm is the better choice

Your usage is genuinely occasional. A release-week smoke run and nothing in between is what pay-as-you-go is for. At 20 device-hours a month you are at $204; the meter only hurts when the team is on devices every day.
Everything else is already in AWS. IAM, CodePipeline, billing on one invoice, a procurement conversation that is already over. That is worth real money to some teams.
You want the first 1,000 minutes free. AWS is currently offering that (normally 250) to try it, and it is a fair way to find out whether your usage is bursty or daily.

If that is you, use it. The rest of this post is about the teams it was not designed for.

Where RobotActions is the better choice

1. The meter changes behaviour, and not in your favour

Per-minute pricing looks cheap until you notice what it does to people. Nobody leaves a session open to poke at a permissions flow. Nobody records a ten-minute exploratory pass "just to see". Bug reproduction — the thing real devices are best at — becomes a cost centre someone has to justify.

Flat per device per month removes the question. A device on your plan is $25 a month whether it ran for four hours or forty; there is no arithmetic before opening a session and no surprise on the invoice. If you want the automation tier, it is $125 a month for that device, and the minutes are still unlimited.

2. An AI agent can actually hold the device

Device Farm has two ways in: upload a test package, or connect a framework to an Appium endpoint. Both assume a script that already exists.

RobotActions exposes the device to an AI agent as MCP tools. Claude Code, Cursor, Cline, or an agent you built can take a screenshot, read the element tree, tap, type and swipe. It can set the GPS position or the app language, capture and mock network traffic, and file the defect it finds — on a real phone, in one loop.

When the agent is driving, it controls the device directly rather than through an automation wrapper. That is why each action lands immediately instead of waiting behind a translation layer. Appium, WebdriverIO and Playwright stay fully supported for your own suites; the agent path is simply not routed through them.

This is included on the free tier. It is not an add-on and not gated behind an enterprise contract.

3. Interaction that feels like a simulator

Device Farm's remote access is a browser session with swipe and gesture support, and a 150-minute clock. It works. It also feels like what it is — a remote screen — and "remote-control lag" is the standing complaint about every real-device cloud.

RobotActions is built so that the device does not feel remote: freeform gestures of any shape, native finger-like touch, real key presses, live video and audio on both iOS and Android. The difference is most obvious on iOS, and you feel it in the first ten seconds of a trial rather than reading about it here.

4. Concurrency you own, no quota to file for

Device Farm's default quotas are five metered devices for automation and two for remote access, per region, raised by a service-quota request. RobotActions has no equivalent request: buy 11 devices and you run 11 sessions at once, sized to the plan and any model on request. There is one region, and it is "wherever your browser is".

5. The extras that usually need a separate tool

Network capture and mocking on real devices — web and native, both platforms — so an agent can fake a 500 mid-run while validating a fix.
Location and language set directly from the web interface or an MCP call, without walking a settings menu.
Chrome DevTools Protocol on iOS Safari as well as Android: DOM, CSS, console, network interception and mocking, one protocol for both.
React Native on iOS with an element tree you can write locators against, where the standard inspector gives you nested wrappers.
Apple TV and Android TV in the same device list, at the same per-device price, with the same Appium drivers as the phones.

The honest cost comparison

Take a four-person mobile team that spends, in total, two hours a day on real devices — one person reproducing, one running a suite, occasional pairing.

	AWS Device Farm	RobotActions
Live device work, ~40 h/month	$408 metered, or $250 for one unlimited slot	$25 per device
Automation, one device slot	$250/month unlimited slot, or metered	$125 per device
AI agent driving the device	not offered	included, from free
150-minute cap	yes	no

The $250 unlimited slot is the fair like-for-like against our $125, and Device Farm is twice the price for a slot without an agent interface. The metered path is cheaper only while the team is barely using it — which is the situation where the meter is doing its job.

Migration

Your Appium suite already speaks to Device Farm through a WebDriver endpoint. Pointing it at RobotActions is the same change in the other direction: set the grid URL, add the token, keep every test. Templates for Appium, WebdriverIO, Selenium, Playwright, Espresso and XCTest are in the public robotactions-automation repo, including the connection recipe.

Try it before you decide

The free tier is one device and ten minutes of device time a day, with the MCP tools included, no card. Run one bug reproduction on it and one agent session, and compare the feel against a Device Farm remote-access session on the same app. That is a better test than anything in this post.

Sign in with Google or GitHub and try it free →