Cloud iOS simulators

A cloud iPhonethat can use your camera.

Run your app in a browser, pass live webcam video into its camera, and exercise mobile workflows that ordinary remote previews cannot reach.

$0.02per active minute$1.20 / hour

Get simulator access See camera passthrough

Live camera relayConnected

Your browserWebcam

LIVE

Browser camera permission

Remote iOSApp camera

CAMERA PREVIEW

Real app capture flow

Inputwebcam

Transportlive video

DestinationiOS camera

$0.02 / min

Pay only while the simulator is active

Live webcam

Browser video into the app camera

Reusable assets

Upload once and install again

Signed browser URL

Open or embed every session

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 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 sessionscamera relayshared 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

Upload media to the simulated device

Present repeatable images and video to camera-dependent flows

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 camera relay, collaboration, and synchronized multi-device workflows

What this unlocks

Test the mobile workflows that usually require a phone.

Video calling

Verify camera acquisition and real-time video flows across broadcaster and receiver simulators.

Camera and social apps

Exercise capture, preview, filters, publishing, and media handoff without keeping a physical device on a desk.

QR and barcode flows

Present controlled visual input to the app camera and reproduce the same scan scenario.

Document capture

Test framing, review, and upload experiences with repeatable document imagery.

Vision features

Give image recognition and computer-vision features stable visual input while you iterate.

Agent-built mobile apps

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

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 simulator

Choose an iPhone or iPad session, 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.

Connect visual input

Use live webcam passthrough or controlled media when the experience depends on the camera.

Mobile simulators

npm install @run-cloud/sdk

simulator.ts

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",
  );
  console.log(session.url);
} 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.3015 min

$0.6030 min

$1.2060 min

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 parallel-simulators --openruncloud demo run eight-device-mosaic --open

FAQ

The practical details.

How much does an iOS simulator cost?

Run Cloud iOS simulator sessions cost $0.02 per active minute. A 15-minute session costs $0.30, 30 minutes costs $0.60, and one hour costs $1.20.

Can the simulator use my webcam?

Yes. The live camera relay workflow connects a browser webcam and passes its video frames into the broadcaster simulator’s camera, where the app can request and display the camera feed.

Can I use prerecorded media instead?

Run Cloud’s simulator stack supports controlled image and video sources for repeatable camera and media testing.

What kind of app build can I install?

The CLI accepts .tar.gz, .zip, .app archives, and .ipa files. The app still needs to be built for the iOS 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.

Test the camera app, not just the buttons.

Put the latest build on a browser-controlled iPhone, connect real visual input, and release the session when the work is done.

Get simulator access Read the quickstart