iOS simulators · Android emulators

A cloud phoneyour agent can drive.

iPhone or Pixel, same API. Install a build, open the exact screen, and stream the session to a browser tab, or embed it in your product and let an agent operate it end to end.

$0.02per active minutemetered while running

Start a simulator See the API

Limrun vs Run CloudCloud iOS simulators and Android emulators compared

Simulator sessionactive

Signed browser URL

modeliphone

statusactive

inactivityTimeout60s

metered$0.02 / min

session up[############]

Open it, embed it, or hand it to an agent

Remote iOSYour build

APP LAUNCHED

Streaming in the browser

Createcli · sdk · api

Installapp · ipa · asset

Releasetimeout or call

$0.02 / min

Pay only while the simulator is active

Signed browser URL

Open or embed every session

Reusable assets

Upload once and install again

iOS + Android

One lifecycle across both platforms

Beyond screen streaming

Most remote simulators stop at the screen.Yours can test what happens in front of it.

Camera-dependent apps need more than taps and screenshots. Run Cloud carries visual input into the app so you can exercise the experience users actually see.

Live camera relay=-#-=-=-Connected

Your browserWebcam

1280x720

REC 00:14

Browser camera permission

━━───────>

Remote iOSApp camera

CAMERA PREVIEW

Real app capture flow

Inputwebcam

Transportlive video

DestinationiOS camera

Live input

Pass your webcam into the app.

Connect a camera in your browser and carry its live video frames into the remote simulator’s camera pipeline.

browser webcamlive videoreal app camera

Repeatable media

Test with a known image or video.

Exercise camera and media flows against controlled visual input instead of pointing a physical phone at a test fixture.

image sourcevideo sourcerepeatable input

Multi-device

See the workflow across devices.

Create simulator sessions in parallel for broadcast, receiver, collaboration, and other device-to-device scenarios.

parallel sessionsdevice to deviceshared canvas

Runnable camera demo

Start one broadcaster and two receivers, then connect your webcam.

runcloud demo run live-camera-relay --open

Beyond remote preview

Screen streaming is table stakes.

Run Cloud gives your product control of the input, the session lifecycle, and the devices around the screen.

Remote preview

Run Cloud

Watch and control a streamed screen

Carry live or controlled visual input into the app camera

Install the build by hand before every review

Install a .app, .zip, .tar.gz, or .ipa at create time, or reuse an uploaded asset

Open a simulator for a human reviewer

Let an agent create, install, deep-link, and release the session

Place a remote device in an iframe

Receive readiness and lifecycle events, then send supported parent commands

Add more concurrent devices

Coordinate collaboration and synchronized multi-device workflows

What you can test

Test the mobile workflows that usually require a phone.

Agent-built mobile apps

Let a coding workflow install a fresh build, open the right deep link, and return a browser session for review.

Pull request review

Share a signed URL so a reviewer lands on the exact screen the change touches, without cloning or building anything.

Live previews in your product

Embed a running device in your own UI and drive it from the parent page while your users watch the app respond.

Smoke tests before release

Install the candidate build, walk the critical flows, and release the session without keeping a device lab idle.

Camera and vision features

Give capture, scanning, and image recognition flows real or repeatable visual input instead of a static placeholder.

Multi-device workflows

Run sessions side by side for collaboration, broadcast and receiver, and other device-to-device scenarios.

From build to browser

Put the latest app on an iPhone in one workflow.

Create a session from the CLI or SDK, install the build, open the right route, and release it when the work is done.

Bring the build

Install a simulator-compatible .app, .zip, .tar.gz, or .ipa while creating the session, or reuse an uploaded asset.

Create the session

Choose an iPhone, iPad, or Android device, add timeouts and labels, and receive a signed browser URL.

Open the exact state

Launch a web URL or your app’s deep link so the reviewer or agent lands in the right flow.

Hand it off

Open the signed URL, embed it in your product, or let an agent drive the session and release it when the task finishes.

Mobile simulators

npm install @run-cloud/sdk

simulator.ts

import { writeFile } from "node:fs/promises";
import { Client } from "@run-cloud/sdk";

const cloud = new Client();
const session = await cloud.ios.create({
  displayName: "Agent smoke",
  inactivityTimeout: "60s",
});

try {
  await cloud.ios.openUrl(
    session.id,
    "https://run.cloud",
  );
  await new Promise((resolve) => setTimeout(resolve, 3000));
  const screenshot = await cloud.ios.screenshot(session.id);
  await writeFile("run-cloud.png", screenshot);
  console.log(`Captured run-cloud.png (${screenshot.byteLength} bytes)`);
} finally {
  await cloud.ios.delete(session.id);
}

Programmable by design

A simulator users can watch.And agents can operate.

Build the simulator into your product instead of wrapping an opaque video stream. Run Cloud exposes the signals and controls needed to manage the experience around it.

Agent-native

Give the simulator to your coding agent.

Install the Run Cloud skill for Claude Code, Codex, or Cursor so an agent can create sessions, install builds, open the right route, and clean up reliably.

agent skillCLI + SDKsafe cleanup

Embed contract

Know when the app is actually ready.

Observe streaming and app-launch readiness, React Native detection, authentication failures, inactivity, and session completion from the parent page.

loading guardreadiness eventslifecycle events

Parent controls

Control the session from your product.

Use the iframe command channel for reload, Home, rotation, screenshots, and the accessibility inspector without rebuilding the surrounding experience.

postMessagescreenshotsaccessibility

Connect an agent

runcloud skills install --agents codex --scope project

Wait for the real ready state

streaming && appLaunched

Simple simulator pricing

Pay for the session.Release it when you are done.

No Mac to reserve and no device lab to keep idle. Active simulator time is metered by the minute.

$0.02/ minute

$0.02 per minute for simulators, metered while the session is active.

Inactivity timeout and explicit release supported

Eight-device mosaicSynchronized

One is not always enough

Run the whole multi-device story.

Start sessions concurrently for collaboration, broadcast, receiver, and visual synchronization workflows.

runcloud demo run eight-device-mosaic --open

FAQ

The practical details.

What teams ask before putting a cloud device in front of users or agents.

How much does a simulator session cost?

Run Cloud simulator sessions cost $0.02 per active minute. Metering runs while the session is active and stops when it is released or times out.

Can the simulator use a camera?

Yes. Connect a browser webcam and its live frames are passed into the simulator’s camera, where the app can request and display the feed. Controlled image and video sources are supported too, so a camera flow can be replayed against the same input every time.

Do you support Android as well as iOS?

Yes. Android emulator sessions use the same create, install, open-url, timeout, label, and release calls as iOS simulator sessions, return the same signed browser URL, and share the same uploaded assets. Pick the platform in the CLI or SDK call.

What kind of app build can I install?

The CLI accepts .tar.gz, .zip, .app archives, and .ipa files for iOS, and Android app artifacts for emulator sessions. An iOS app still needs to be built for the Simulator runtime; a device-signed App Store IPA is not a substitute for a simulator build.

Can I embed a simulator in my own product?

Yes. Each session includes a signed browser URL for an iframe. The parent page can observe streaming and app readiness, authentication, inactivity, and session completion, then send supported commands for reload, Home, rotation, screenshots, and the accessibility inspector.

Can a coding agent operate the simulator?

Yes. Install the Run Cloud agent skill for Claude Code, Codex, or Cursor. It teaches the agent to create sessions, install simulator builds, open URLs and deep links, and release sessions when the task finishes.

What happens when capacity is full?

The create request waits for compatible simulator capacity within its queue window. If capacity becomes available, the session is returned normally with queue timing details.

Put the build on a phone in seconds.

Create a session from the CLI, the SDK, or an agent, open the exact screen you care about, and release it when the work is done.

Start a simulator Read the quickstart