Your agent gets a phone.
You get the same one.
PreviewAPK is a real phone in the cloud that your AI agent can use just as you would. It builds the app, runs it, taps through every screen, reads the UI and the logs — it tests and debugs its own work. Then it hands the phone to you: open your portal and test the feature yourself, live. No Android Studio, no local SDK, no emulator on your machine, no Play Store upload. No minute meter running. (Showing a client is one view-only link — a byproduct, not the pitch.)
Launching soon. One email when your invite is ready — no newsletter, no drip campaign.
The agent’s terminal and its phone — one session, both sides at once, on every screen.
From build to live preview in three steps
No SDK in your codebase, no emulator to install, no device farm to configure. If you can export an APK, you can do this.
Push your build
Drag in a debug or release build — or push it with one command from your terminal, your CI, or your AI agent. We boot it on a real cloud emulator — same Android runtime, no repackaging, nothing added to your app.
It boots in seconds
Your build starts on a cloud phone — the real Android runtime, your app exactly as built, nothing repackaged. You, your agent, and your CI all use the same door: the API or CLI starts it, the portal shows the same phone, and the session's share link covers anyone who should watch.
Watch it. Drive it. Verify it.
Watch the real app live in your browser and tap through the new feature yourself — or let your agent do it: driving the app, screenshotting what it sees, reading the UI and the logs, and reporting back what actually happened.
No more “test it and let me know.”
The old way ends with your agent saying “I've built this feature — now you test it and tell me how it goes.” With a phone of its own, it doesn't have to: your agent gets eyes and ears inside the app it is building — it drives the app, sees its screen, reads its buttons, and hears its logs, so it verifies its own work before it goes on a victory lap and claims “done.”
The agent pushes the build
One CLI command, one API call, or a native MCP tool: previewapk push app.apk --run. The build lands on its phone and starts.
The agent checks its own work
In agent-driven sessions it has the full set of senses: it can tap and type, take screenshots it can actually see, read the screen's UI tree to find the exact button, and read the app's logs — so when something breaks, it knows why. That's the difference between an agent that builds blind and one that checks its own work.
Then it hands you the phone
“Built it, tested it — here, take the phone.” You open your portal — same phone, same session — watch it live, and take the wheel whenever you want to tap through it yourself.
Works with your existing agent.
PreviewAPK is an MCP server, a CLI, and an API. Whatever agent you already pay for can drive the phone — push a build, tap through it, and see exactly what it made.
…and anything else that speaks MCP, runs a shell, or can make an HTTPS call.
Not sure it’s for you? Ask the one who’d use it.
PreviewAPK is a tool for agents — and for the humans who work with them. So don’t take our word for it: paste this into the agent you already use, and let it judge for itself.
Fetch this skill file: https://previewapk.siteport.site/skills/previewapk/SKILL.md It's a service that gives you a real cloud Android phone — you can push an app, run it, tap through it, read its logs, and verify your own work. Based on what you know about my projects and how I currently build and test mobile apps, tell me honestly: would this meaningfully improve my development or testing? Compare it against how I test today, name what it would replace or speed up — and say plainly if it wouldn't help me. If it would help, tell me the first thing you'd use it for.
No signup needed — your agent reads the same skill file it would use to drive the phone.
No install. No SDK.
A URL and a key.
The MCP server is hosted. Your agent connects to a live phone with the endpoint URL and its API key — there is nothing to download and nothing to keep updated, and the endpoint is listed on the official MCP registry.
Connect
Point your agent at previewapk.siteport.site/mcp and give it your API key. That is the whole setup — no file to install, no server to run on your machine.
27 tools
The full driving set: push a build, start the phone, tap and type, screenshots and the UI tree, app logs, screen recordings, device controls — the same tools over MCP, the CLI, and the API.
No queue
Agent sessions run in parallel. Agents do not line up behind each other — every call goes straight to its own session.
When you do want an audience,
it's one link.
Sharing is a byproduct of the loop: when a session runs, it has one view-only share link — a mirror, not a hand-off. The link lives exactly as long as the session does. No settings, no toggles: watching is all a link can ever do.
That's the whole panel — in your portal it looks exactly like this. There's nothing to configure, because a link can only ever watch.
View-only, by design
Viewers see your screen in real time, but there's nothing for them to press. No stray taps, no one typing into your forms, no wandering into a half-finished settings screen. The session goes where you take it.
Links end with the session
Stop the run and the link is dead — not disabled, dead. While it lives, it can only watch. There's nothing to revoke, expire, or misconfigure, because the link was never a key to anything. The client who got the link last week holds a dead URL.
Install on your own phone
Some builds need real hardware. From your portal, any attached APK offers Install on my phone: a QR code whose link installs that exact build on your device. It lives for 15 minutes, it's minted inside your account, and it's the only download in the product — share links never serve files.
No minute meter
A client demo that runs long isn't a billing event. Stream for five minutes or five hours, to two people or two hundred — the price at the end of the month is the price you signed up for.
Runs in any browser
Chrome, Safari, Firefox, Edge — laptop, tablet, or the phone in your client's pocket. If they can open a link, they can watch the preview. No account, no plugin, no "please install this first" email chain.
Your agent knows when to ask for help.
Some steps are not an agent’s to make — a password, a 2FA code, a payment confirmation. When a run reaches one, the agent stops and asks you instead of guessing.
It stops at the wall
The agent files a request with the reason attached — “the app is asking for a 2FA code” — and you get it in chat, with a link to the portal.
You do the one step
Open the portal, take the wheel on the same phone, and type the secret on the phone yourself. It is never pasted into a chat and never handed to the agent.
It picks the wheel back up
Hand control back — with a short note if you want, “approved, continue.” The agent sees the handback on its own and resumes the run. Nobody has to announce it in chat.
Every run ends with a report card.
When the agent finishes, it files a report: what it tested, what it did, and what went wrong. The counts are kept by the system while the run happens — the agent reports them, it does not invent them. You get the report in chat, with a link to the portal.
The phone stays live after the report — open the portal link and you are looking at the exact screen the run ended on.
One plan. One price.
No minutes.
That's the whole pricing page. You pay per device slot. Everything is unlimited — previews, viewers, and minutes.
Get early accessWHAT'S INCLUDED
- One share link per session — view-only, and it dies with the session, so feedback can't land on the wrong build
- Hosted MCP endpoint — your agent connects with a URL and a key; nothing to install, 27 tools
- Unlimited viewers — send the link to the whole team or the whole company
- Unlimited minutes — long demos don't cost extra
- Install on your own phone — a short-lived QR from your portal puts the build on your real device
- Revocable, expiring links — access ends when you say it ends
- Display controls — phone frame and Android navigation buttons, per link
The Appetize comparison, since you'll ask
Appetize is a solid platform — built for enterprise QA farms, and priced like it. PreviewAPK is built for the build → preview loop.
| Appetize | PreviewAPK | |
|---|---|---|
| Price | $59/month | $19/month per device |
| Streaming minutes | 500 included — then metered | Unlimited. There is no meter. |
| Built for | QA, test automation, support desks — a full device platform | Previewing builds fast — developers, CI, and AI agents — and sharing them with people |
| Viewer experience | Interactive session — viewers can take control | View-only mirror. You — or your agent — drive; they watch. |
| Agent access | API and embeds, for your own tooling | Hosted MCP — 27 tools behind a URL and a key. Nothing to install. |
| When an agent needs a human | Not part of the model | The agent asks, you do the one step in the portal, and it resumes on its own. |
| End-of-run report | Session playback | A report card per run — what was tested, actions, errors — counted by the system. |
Fair questions
How is this different from Appetize?
Do viewers need to install anything?
Is "unlimited" really unlimited?
Can viewers tap around in my app themselves?
Can people download my APK from the link?
Can I try the build on a real phone?
What kind of APK can I upload?
The build-to-preview loop, covered end to end.
Tools, guides, and honest comparisons for getting an APK in front of the people who need to see it.
Tools
Guides
Your next build could be running in seconds.
PreviewAPK is in private beta. Get early access and we'll send your invite as spots open — early members lock in the $19 launch price.
One email when your invite is ready. That's the whole email strategy.