Appetize vs Run CloudThe same phone in a browser, at a third of the price.
Both platforms run iOS and Android in a browser tab. Appetize.io has been doing it for years, and it shows: a scripted automation SDK, network and log inspection, a deep device matrix, and the enterprise paperwork to match. Run Cloud comes at the same problem from the agent side — iOS simulators and Android emulators on one API at a third of the price, plus live camera input, cloud Xcode builds, and Linux sandboxes on the same key. This is where each one wins.
Appetize
$0.06
per minute, iOS and Android sessions
Run Cloud
$0.02
per active simulator minute
Published 2026-07-25 · Appetize details are taken from appetize.io and docs.appetize.io as published in July 2026. Check both sets of docs before committing.
At a glance
| Topic | Appetize | Run Cloud |
|---|---|---|
| Platforms | iOS simulators and Android emulators, across a broad matrix of device models and OS versions. | iOS simulators and Android emulators, both first-class: the same create, install, open-url, timeout, and release calls on either platform. |
| Session price | $0.06 per minute for iOS and for Android sessions, inside plan tiers. | $0.02 per active simulator minute, published, self-serve, no plan tier to negotiate. |
| Programmatic control | JavaScript SDK drives taps, swipes, typing, and element queries; Playwright-based AppRecorder for end-to-end tests. | Create, install, open URL, screenshot, and release, plus the embed command channel. Scripted control is planned. |
| Debugging | Network traffic monitor, debug logs, UI hierarchy inspection, and session history reporting. | Screenshots and the accessibility inspector through the embed channel; no network capture today. |
| Camera input | Media upload onto the device; no live webcam passthrough documented. | Browser webcam carried into the app camera, plus uploaded video, images, and microphone audio. |
| Builds | You upload a build that was compiled somewhere else. | Xcode sandboxes build in the cloud, sign, export a signed IPA, and upload to TestFlight. |
| Beside the device | Mobile devices are the product. | Firecracker Linux microVMs with snapshot, fork, pause, and resume on the same API and bill. |
| Enterprise controls | SAML and OIDC SSO, private cloud and self-hosting options, usage reporting, ISO 27001 certification. | Self-serve accounts, API keys, and organization billing; no SSO or self-hosted option today. |
What Appetize is
Appetize runs native iOS and Android apps in a browser tab. You upload a build — an APK, or a zipped .app bundle — and it becomes a link anyone can open, or an embedded device inside your own site. Sessions can be configured per launch: device model, OS version, language and locale, mocked location, proxy, deep links, and launch params.
Its automation surface is the part worth studying. The JavaScript SDK drives the device programmatically — taps, swipes, typing, element queries — and AppRecorder turns a recorded session into Playwright end-to-end tests that run in CI. Around the session there is real debugging: a network traffic monitor, debug logs, and UI hierarchy inspection. For larger buyers it adds SAML and OIDC single sign-on, session-history reporting, private cloud and self-hosted deployment, and ISO 27001 certification.
Appetize documentationWhat Run Cloud is
Run Cloud is one API for the computers an agent needs. iOS simulators and Android emulators are both first-class — the same calls, the same asset store, the same signed browser URL — and they sit beside Firecracker Linux microVMs and Xcode sandboxes that archive, sign, and export a signed IPA. A session is created from the runcloud CLI or the @run-cloud/sdk TypeScript client, installs your build, and returns a signed browser URL along with labels, inactivity timeouts, and hard timeouts.
Two things set it apart from a browser-streamed device. The first is input: a browser webcam can be carried into the simulator's camera pipeline, and uploaded video, images, or microphone audio can be replayed so a capture flow gets the same input every run. The second is scope — the phone sits beside Linux compute and Apple build infrastructure on the same key and the same invoice, instead of being a separate vendor bolted onto your stack.
Run Cloud simulator documentationPrice: $0.06 against $0.02
Appetize sessions run $0.06 per minute for iOS and for Android. Run Cloud simulator sessions are $0.02 per active minute. That is a third of the price for the same minute of device time, and the difference compounds with usage: a thousand session minutes a month is $60 against $20, and ten thousand is $600 against $200.
Model your own number rather than the headline. Ask what starts and stops the meter, whether idle time before an inactivity timeout is billable, and whether minutes come bundled into a plan tier you have to size in advance. Run Cloud publishes its rate and bills active minutes with self-serve billing; there is no tier to negotiate before you can run something.
Run Cloud pricingAutomation and debugging
This is where Appetize is genuinely ahead today. Its JavaScript SDK drives the device directly and AppRecorder produces Playwright tests from a recorded session, so a QA team can go from clicking around to a suite running in CI. Network traffic capture, debug logs, and UI hierarchy inspection turn a session into something you can diagnose rather than just watch.
Run Cloud's documented surface is session lifecycle, app install, open URL, screenshot, media upload, and release, with interactive control through the signed stream or the iframe command channel. First-party scripted control is planned, but if a tap-and-assert suite is the reason you are shopping, Appetize does that today and Run Cloud does not.
What runs beside the device
Appetize is a device platform: you bring a build compiled elsewhere and it runs. That focus is a strength — the device matrix, the configuration options, and the deployment models are deeper for it. But the build pipeline and any compute around it stay your problem.
Run Cloud covers more of the loop. An Xcode sandbox can compile the source, sign it, export a signed IPA, and push to TestFlight; a Firecracker microVM can run the agent or the test harness that drives everything, with snapshot, fork, pause, and resume. One API key, one invoice, whether the workload needs a phone screen, a Linux box, or both at once.
Where each one is strong
Appetize
- A mature automation surface: the JavaScript SDK taps, swipes, types, and queries elements, and AppRecorder generates Playwright tests from a recorded session.
- Debugging depth around the session — network traffic capture, debug logs, and UI hierarchy inspection — rather than only a picture of the screen.
- A wide device and OS matrix, with language, locale, mock location, proxy, deep links, and launch params configurable per session.
- Deployment and governance options large organizations ask for: private cloud, self-hosting including AWS, SAML and OIDC SSO, session history, and ISO 27001 certification.
Run Cloud
- Both platforms, not a phased rollout: iOS simulators and Android emulators share one API, one lifecycle, one asset store, and one rate.
- A third of the price per minute: $0.02 against $0.06, published rather than quoted, on active minutes only.
- Live camera input — a browser webcam carried into the app camera, plus repeatable video, images, and microphone audio.
- Xcode sandboxes that build, sign, export a signed IPA, and upload to TestFlight, so the build does not have to happen somewhere else first.
- Firecracker Linux microVMs with snapshot, fork, pause, and resume, on the same API and the same invoice as the phones.
- Agent-native from the start: a CLI, a TypeScript SDK, and an installable skill for Claude Code, Codex, and Cursor.
- Self-serve sign-up, API keys, and billing, with no plan tier or sales conversation in the way.
Which one should you pick?
Choose Appetize when
- You want recorded or scripted UI tests against cloud devices today, not on a roadmap.
- You need network traffic capture, debug logs, and UI hierarchy inspection while a tester drives the app.
- Your matrix matters: many device models, OS versions, locales, and mocked locations.
- Procurement needs SSO, self-hosting, or an ISO 27001 certificate before anything ships.
Choose Run Cloud when
- Per-minute cost matters at volume, and three times the rate is three times the bill.
- Your app depends on the camera or microphone: QR scanning, document capture, video calling, vision features.
- The same workflow needs Linux compute, or needs the iOS build itself produced in the cloud.
- An agent, not a person, is creating sessions, installing builds, and cleaning them up.
Plenty of teams will land on both for a while: a QA suite that already runs on Appetize is not worth rewriting on day one, while new agent workloads and customer-facing embedded sessions start on the cheaper minute.
Frequently asked questions
How does Appetize pricing compare to Run Cloud?
Appetize sessions are $0.06 per minute for iOS and for Android. Run Cloud simulator sessions are $0.02 per active minute, published on the pricing page and available self-serve. For the same session time, Run Cloud is a third of the cost; at a thousand session minutes a month that is $20 against $60, and the gap scales linearly from there.
Is Run Cloud a drop-in replacement for Appetize?
Not for every workflow. If you rely on the Appetize JavaScript SDK for scripted taps and assertions, on AppRecorder-generated Playwright tests, or on network traffic capture, those have no direct Run Cloud equivalent today — scripted control is planned. If you use Appetize to install a build, open a screen, share a link, or embed a device, Run Cloud covers that now at a lower rate.
Can both embed a device in my own product?
Yes, and both are built for it. Appetize embeds the device with its JavaScript SDK and supports custom branding, custom launch pages, and reserved devices. Run Cloud returns a signed session URL for an iframe, with an embed mode, an optional loading guard, readiness and lifecycle events, and a postMessage channel for reload, Home, rotation, screenshots, and the accessibility inspector.
Can I test camera flows on either platform?
Appetize documents uploading images and media onto the device, but not live camera passthrough. Run Cloud connects a browser webcam and carries its frames into the app camera, and can also replay an uploaded video or image so the same visual input runs every time.
Which one handles builds?
Appetize expects a compiled build — an APK for Android, or a zipped .app bundle for iOS — produced by your own pipeline. Run Cloud can run that pipeline too: an Xcode sandbox builds your source in the cloud, signs it, exports a signed IPA, and uploads to TestFlight, and Xcode builds are free during beta.
What about SSO and self-hosting?
Appetize is ahead here. It documents SAML and OIDC single sign-on, session-history reporting, private cloud, and self-hosted deployment including AWS, and holds ISO 27001 certification. Run Cloud today is self-serve accounts with API keys and organization billing.
Run the same session for a third of the price.
Create a session, install your build, open the exact screen, and release it when the work is done. Sign-up and billing are self-serve, and you are billed by the active minute.