Servidor MCP de MAS

Servidor MCP para Android para Claude Code, Cursor, Codex y cualquier cliente MCP

41 herramientas que le dan a tu cliente de IA ojos y manos en Android: capturas que puede mirar, OCR y coincidencia de plantillas, toques, deslizamientos y escritura, ejecuciones de macros y un agente que construye una macro a partir de una frase. Controla BlueStacks, LDPlayer, MuMu, MEmu o cualquier emulador compatible con adb en Windows o Mac, un teléfono conectado a tu PC o dispositivos Android en la nube siempre encendidos, desde el cliente que ya usas.

El servidor alojado con tu clave de MAS en una cabecera, y después el servidor local por URL mientras la app esté abierta.

claude mcp add --transport http mas-cloud https://api.automationmacro.com/mcp --header "X-API-Key: $MAS_API_KEY"
claude mcp add --transport http mas-local http://127.0.0.1:3846/mcp
Descargar la app Conoce MAS Agent Documentación de configuración

Qué es

Qué hace el servidor MCP para Android de MAS

MCP es el protocolo que usan los clientes de IA para llamar a herramientas externas. Este servidor convierte un dispositivo Android en esas herramientas. Tu cliente pide una captura y recibe una imagen que puede mirar; pregunta qué dice la pantalla y recibe líneas de OCR con su confianza y sus cajas; envía una plantilla y recibe dónde está; toca, desliza, escribe y pulsa teclas; abre y cierra apps. Eso es lo que hace cualquier servidor MCP para Android, y funciona igual en un emulador, en un teléfono conectado o en un dispositivo en la nube.

El servidor de MAS hace además lo que un servidor de dispositivo no puede. Lee y ejecuta las macros de tu biblioteca, le pide a MAS Agent que explore una app y devuelva una macro Python terminada, y expone el mapa que el agente aprendió de esa app, además de la referencia completa del SDK como recurso MCP para que tu cliente escriba código de macros con el estilo de la casa. Eso lo convierte en un servidor MCP para automatización Android en la capa del dispositivo y en un servidor MCP de automatización móvil en las capas de arriba: macros, el agente, los mapas. No es un plugin de Android Studio ni un asistente de programación. Controla el dispositivo.

Servidor alojado

Las 41 herramientas, en tus dispositivos en la nube

Un único endpoint HTTP remoto. Reserva un dispositivo en la nube, contrólalo, ejecuta macros en el servidor, crea otras nuevas con el agente, lee mapas de app. Nada que instalar, y tu equipo puede estar apagado.

Servidor local, en la app

38 herramientas, en tu equipo

La app de escritorio es el servidor. Actívalo en Integraciones (MCP) y apunta tu cliente a la URL de loopback. Controla todo lo que adb pueda ver, BlueStacks, LDPlayer, MuMu, MEmu en Windows o macOS o un teléfono con depuración USB, y se trae consigo tu biblioteca de macros, la biblioteca de imágenes, la creación con el agente, el bucle de desarrollo y el programador.

Emuladores

Controla emuladores Android: BlueStacks, LDPlayer, MuMu, MEmu en Windows o Mac

El servidor local es un servidor MCP para emuladores Android pensado para el emulador que ya tienes en tu escritorio. Actívalo en Integraciones (MCP), dentro de la app, y apunta tu cliente a http://127.0.0.1:3846/mcp. Cada herramienta de dispositivo acepta un device, el id que da list_devices, un serial de adb o el puerto a secas, y puedes omitirlo cuando solo hay un emulador en marcha. La app trae su propio adb, así que esta es la configuración de MCP con emulador Android que busca casi todo el mundo: un interruptor, una URL, listo.

  • BlueStacks
  • LDPlayer
  • MuMu
  • MEmu
  • Windows
  • macOS

Los juegos son el caso que rompe los servidores basados en árbol de accesibilidad: no hay árbol que leer. Los dos servidores trabajan a partir de píxeles, así que un modelo puede recorrer la pantalla de un juego igual que la pantalla de ajustes.

Dispositivos en la nube

Dispositivos Android en la nube, nada que instalar

El servidor alojado llega a los dispositivos siempre encendidos que MAS ejecuta por ti. lease_device abre una sesión de control y devuelve el id de reserva que necesita cada herramienta de dispositivo; activa auto_start y arrancará antes un dispositivo detenido. La reserva se renueva en cada llamada y caduca tras 10 minutos de inactividad, así un cliente olvidado no puede retener un dispositivo para siempre. run_macro se ejecuta en el dispositivo en el servidor y author_macro pone a MAS Agent a trabajar en él, ambos con tu equipo apagado.

Las herramientas de dispositivo no tienen cargo por llamada; funcionan en los dispositivos en la nube de tu cuenta, $80/mes cada uno con la asignación mensual de créditos. Ver dispositivos en la nube.

Tu propio teléfono

Un servidor MCP por ADB para el teléfono que tienes en la mesa

Activa la depuración USB, conecta el teléfono y el servidor local lo lista junto a tus emuladores. Todas las herramientas de pantalla, entrada y visión funcionan en él: un modelo puede controlar un teléfono Android por MCP igual que controla un emulador, desde el cliente que ya usas, sin instalar nada en el teléfono.

Visión

Capturas que el modelo puede ver, OCR y coincidencia de plantillas

  • screenshot devuelve la pantalla como contenido de imagen, así el modelo la mira directamente en vez de adivinar a partir de un árbol. El servidor local la escala por defecto a 1280 px en el lado largo e informa del factor de escala.
  • read_text ejecuta OCR sobre la pantalla o sobre una región y devuelve cada línea con su confianza y su caja delimitadora, así "toca la palabra Reclamar" es una coordenada, no una esperanza.
  • find_image busca con OpenCV la plantilla que envías, con un umbral que controlas tú, y devuelve la puntuación y el centro que tocar.

Herramientas

Las 41 herramientas

Cada herramienta por su nombre, con sus parámetros. Las herramientas "local y alojado" existen en las dos superficies; las pocas que no, llevan marcada la superficie a la que pertenecen.

Device control

Pick a device and drive it: the same taps, swipes and keys a person would use.

  • get_status local y alojado
    Call this first. What the server is, whether the account can run anything (subscription, AI credits), the devices it can reach, and hints, including that local emulators are only reachable through the desktop app's local server. The same body as the mas://status resource; needs no scope.
  • list_devices local y alojado
    List the devices the server can reach, with their state. On the hosted server that is your cloud devices and quota; on the local server, the emulators the app sees over adb (id, serial, port, whether a macro is using one).
  • lease_device (device_id, auto_start) alojado
    Open a control session on one of your cloud devices and get the lease_id every device tool needs. auto_start boots a stopped device first. A lease renews on every call and expires after ten idle minutes; one lease per device, and a device that is running a macro cannot be leased.
  • release_device (lease_id) alojado
    End the control session. The device keeps running.
  • tap (x, y) local y alojado
    Tap the screen at device coordinates.
  • swipe (x1, y1, x2, y2, duration_ms) local y alojado
    Swipe between two points for scrolling and flicks, with a chosen duration (default 300 ms).
  • long_press (x, y, duration_ms) local y alojado
    Press and hold at a point for duration_ms (default 800, 100 to 5000): context menus, drag handles, app icons.
  • drag (x1, y1, x2, y2, duration_ms) local y alojado
    Touch down, move to a second point over duration_ms (default 600, 100 to 5000) and release: slow enough for sliders and drag-and-drop, unlike a flick swipe.
  • type_text (text) local y alojado
    Type text into the focused input field.
  • press_key (key) local y alojado
    Press BACK, HOME, ENTER, TAB, DEL or any KEYCODE_ name.
  • open_app (package) local y alojado
    Launch an app by package name.
  • close_app (package) local y alojado
    Force-stop an app by package name.
  • current_app local y alojado
    Report the package in the foreground.
  • screen_size local y alojado
    Return the screen size in pixels, the coordinate space for tap and swipe.
  • wait (ms) local y alojado
    Pause for animations and loading screens: up to 10 seconds per call on the hosted server, up to 60 seconds locally. Prefer wait_for when you know what you are waiting for.

Screen understanding

Let the model see the screen and locate things on it without guessing coordinates: pixels, OCR, template matching and the accessibility tree.

  • screenshot (max_width) local y alojado
    Capture the screen and return it as an image the model looks at directly. Pass max_width (200 to 2000) for a smaller image; the reply then reports the scale, and tap coordinates stay in device pixels (device_x = image_x / scale). The local server limits the long side to 1280 px by default and always reports the scale.
  • read_text (region {x1, y1, x2, y2}) local y alojado
    OCR the whole screen or one region into text lines. The hosted server returns a confidence and a bounding box per line; the local server returns the lines and the scanned box.
  • find_image (template_base64 | image_id, threshold) local y alojado
    Locate a template on screen with OpenCV matching and return the score and tap coordinates. The template is inline (template_base64) or an image_id from your image library, so a crop made once with crop_image is found every time.
  • get_ui_tree (max_nodes) local y alojado
    The Android accessibility hierarchy as compact text, one visible element per line with its class, id, text, description, bounds and flags. Cheaper and more exact than a screenshot for buttons, fields and labels; games and canvas views expose little.
  • find_element (id, text, desc, class, contains, index) local y alojado
    Find UI elements by resource id, text, content description and/or class (selectors combine). Returns the match at index with its bounds and tap centre, plus up to 20 matches. contains=true (default) matches substrings.
  • wait_for (image_id | template_base64 | text | element {id, text, desc, class}, threshold, timeout_ms, interval_ms) local y alojado
    Poll the screen until one target appears or timeout_ms (default 15000, max 60000) passes: a library image (image_id) or inline template, on-screen text (OCR), or a UI element selector. Returns where it was found and the elapsed time. Use it instead of wait plus screenshot loops.

Macros and runs

Your macro library, readable and runnable from the client. Hosted runs execute server-side on a cloud device; local runs are the editor's Run button on your emulator.

  • list_macros (page, page_size) local y alojado
    List your saved macros with name, id and type (code, or legacy for a retired block macro).
  • get_macro_code (macro_id, file) local y alojado
    Read a code macro's project: the entry script and the file listing by default, or one file you name.
  • run_macro (macro_id, device_id, args) local y alojado
    Start a saved code macro with optional argument overrides and return a run_id at once. Hosted: server-side on a cloud device of yours (it starts if stopped). Local: on the named emulator, which stays busy for the other device tools until the run ends.
  • get_run (run_id) alojado
    The state of a hosted run, from launching through running to finished or failed, with its message and timings.
  • get_run_status (run_id) local
    The state of a local run (running, stopping, completed, failed, stopped), its timestamps and the exit code once it ended. The local name for get_run.
  • stop_run (run_id) local y alojado
    Stop a running macro.
  • get_run_log (run_id, max_lines) local y alojado
    The trailing stdout and stderr lines of a run, newest last, while it runs or after. Hosted runs come from run_macro, validate_macro or a schedule.

Image library

Your Image Library, the same one the app shows: crop a control once, then find it by id from any tool or macro.

  • list_images (folder, query, limit, page) local y alojado
    List your library images, newest first, optionally within one folder or matching a name substring; each with id, name, folder, pixel size and byte size.
  • get_image (image_id) local y alojado
    Fetch one library image by id: the picture itself, to confirm it is the template you mean, plus its name, folder and size.
  • crop_image (region {x, y, width, height}, name, folder) local y alojado
    Crop a rectangle of the device's current screen into the library as a PNG template and return its new image_id with a small preview. The region is clamped to the screen; at least 8 by 8 pixels must remain; a name already used in the folder gets a numeric suffix.

Agent authoring

Hand a goal to MAS Agent and get a finished macro back, from any client.

  • author_macro (prompt, device_id, model, macro_id, parent_session_id, pipeline) local y alojado
    Ask MAS Agent to build a macro from a plain-language goal: it explores the app on the device, captures what it needs, writes and validates the macro. macro_id improves one of your macros instead, parent_session_id continues an earlier session, pipeline picks how the code is produced (build, review, author, author_fast). Async and minutes long; returns a session_id. Hosted authoring always uses the metered cloud model; local authoring uses the provider the app has selected (provider overrides it).
  • get_agent_session (session_id, after_seq) local y alojado
    Progress of an authoring session: state, summary, the macro id once it exists, and any question the agent is waiting on. Hosted sessions also return the transcript events after your cursor.
  • answer_agent_session (session_id, qid, answers) local y alojado
    Answer the agent's pending question so it can continue. Hosted: qid plus an answers object keyed by question header; local: one answer string (an option label or free text).
  • stop_agent_session (session_id) local y alojado
    Stop a session early. Work done so far is saved.

Developer loop

Write a macro yourself, in the house style: scaffold the project, install it as a code macro, prove it with one run.

  • scaffold_macro (name, activities, description, app_package) local y alojado
    Generate the house project skeleton for a new code macro: src/app.py wiring, one src/activities/<name>.py stub per activity, common_logic.py, the scheduler library, task.yaml, ui.xml, requirements.txt and README.md. Pure: nothing is saved; returns {files: {path: content}} for you to fill in.
  • install_macro (name, files, macro_id, description) local y alojado
    Create a code macro from project files, or replace the code of one of yours when macro_id is given, through the same create and code-sync path the app uses. files is {path: content}, 2 MB total; the code is syntax-checked on intake. The local server also takes project_dir, a folder on your PC.
  • validate_macro (macro_id, device_id, timeout_s, args) local y alojado
    Run a macro once and wait for the verdict: passed, exit code and the log tail. Hosted: one run on a cloud device, default 300 s; a run still going at the timeout is stopped. Local: the engine's validation job on your emulator, which also checks task.yaml; pass macro_id or project_dir, and runs (1 to 5) for the graduation ladder.

App maps

What the agent has learned about an app, readable by your client.

  • get_map (package, profile) alojado
    The learned menu map of an app: its screens and the proven routes between them.

Scheduling

The same scheduler the app's Schedule card uses. Hosted jobs run on a cloud device with your PC off; local jobs fire while the app is open.

  • schedule_macro (macro_id, device_id, at, every, timezone, name, weekdays) local y alojado
    Schedule a code macro to run without you: once at `at` (RFC 3339) or recurring with every = daily, weekly (with weekdays) or monthly, in an IANA timezone. No hourly recurrence: a macro that repeats within the day recurs itself. Missed occurrences are skipped; the job pauses after three consecutive failures. Returns job_id and next_run_at.
  • list_schedules (status, target, page) local y alojado
    Your scheduled jobs, cloud and local, with status, next and last run, failures and the auto-pause reason. Filter by status or target.
  • cancel_schedule (job_id) local y alojado
    Delete a scheduled job for good; a run still going on a cloud device is stopped first. Use the app to skip one occurrence or pause a job.

Recursos

Documentos que publica el servidor para que un cliente pueda escribir código de macros sin salir de la conversación.

  • mas://status Read first: the server, the account (subscription, AI credits), the devices it reaches, connected clients on the local server, and where local emulators live (the desktop app).
  • mas://docs/sdk-reference The complete reference of the pre-installed mas SDK macros are written against: device control, vision, elements, app management, storage, types and exceptions.
  • mas://docs/house-library The house library MAS Agent builds macros with: the scheduler skeleton, the activity runner and the runtime-UI template that scaffold_macro ships verbatim.

Configuración

Añádelo en un minuto

El servidor alojado usa tu clave en cada petición: crea una en la app, en Integraciones (MCP) o en API keys, marca los alcances que quieras y envíala en una cabecera X-API-Key o Authorization. Un cliente que prefiera una credencial de corta duración puede cambiar la clave por un token de acceso que dura 1 hora, y un cliente que inicia sesión de forma interactiva obtiene sus propios tokens. El servidor local no necesita clave alguna. 

curl -s -X POST https://api.automationmacro.com/api/mcp/oauth/token -d grant_type=client_credentials -d client_secret=$MAS_API_KEY

Claude Code

El servidor alojado con tu clave en una cabecera, y después el servidor local por URL mientras la app esté abierta:

claude mcp add --transport http mas-cloud https://api.automationmacro.com/mcp --header "X-API-Key: $MAS_API_KEY"
claude mcp add --transport http mas-local http://127.0.0.1:3846/mcp

Cursor

En .cursor/mcp.json, los dos servidores como entradas HTTP:

{
  "mcpServers": {
    "mas-cloud": {
      "url": "https://api.automationmacro.com/mcp",
      "headers": { "X-API-Key": "<your key>" }
    },
    "mas-local": { "url": "http://127.0.0.1:3846/mcp" }
  }
}

Codex CLI

En ~/.codex/config.toml, con la clave en una variable de entorno; el servidor local es codex mcp add mas-local --url:

[mcp_servers.mas-cloud]
url = "https://api.automationmacro.com/mcp"
bearer_token_env_var = "MAS_API_KEY"

Hermes, OpenCode, Gemini CLI y el resto

Cualquier cliente que acepte un servidor HTTP con una cabecera. Claude Desktop lanza un comando en lugar de eso, así que recibe la propia app como puente hacia el servidor local; la app te enseña el bloque con tu ruta de instalación ya puesta.

{
  "mcpServers": {
    "mas-cloud": { "type": "http", "url": "https://api.automationmacro.com/mcp", "headers": { "X-API-Key": "<your key>" } },
    "mas-local": { "type": "http", "url": "http://127.0.0.1:3846/mcp" }
  }
}

Compruébalo: pide a tu cliente que liste los dispositivos y después una captura. Endpoint https://api.automationmacro.com/mcp, protocolo 2025-06-18, documentos de descubrimiento en /.well-known.

El agente, como herramienta

author_macro: de una exploración con IA a una macro Python terminada

La mayoría de servidores MCP para Android se quedan en el dispositivo. Este te entrega el agente. author_macro toma un objetivo en lenguaje natural y un dispositivo en la nube y arranca una sesión de MAS Agent que explora la app, captura de la pantalla en vivo las imágenes plantilla y las regiones de texto que necesita, compila una macro Python determinista y la valida por repetición. get_agent_session devuelve la transcripción con un cursor y cualquier pregunta que haya hecho el agente; answer_agent_session la responde. La macro terminada aterriza en tu biblioteca con su id en la sesión, lista para run_macro, y cada ejecución posterior cuesta cero créditos de IA. Ver MAS Agent.

QA

Pruebas de apps Android y flujos de QA

Apunta un cliente a una build de pruebas en un emulador o en un dispositivo en la nube, recorre el flujo con tap, type_text y press_key, y comprueba cada pantalla con read_text o find_image. Recorre el flujo una vez con author_macro y se convierte en una comprobación repetible que puedes programar. Prueba la app a través de la pantalla como lo haría un usuario; no es un framework de pruebas unitarias.

Seguridad

Servidor remoto, transporte HTTP, claves con alcances y un servidor local que solo responde a tu equipo

El servidor alojado es JSON-RPC sin estado sobre HTTPS en un único endpoint. Las claves se crean en la app, se muestran una sola vez, pueden llevar fecha de caducidad y se revocan con un clic; los tokens generados a partir de ellas duran 1 hora y mueren con la clave. Cada clave lleva solo los alcances que le concedes:

  • devices:control lease a cloud device, see its screen, tap, type, manage apps and the image library
  • macros:run list and read macros; start, check, validate and stop runs; read run logs; manage schedules
  • macros:author start, follow, answer and stop an agent authoring session; scaffold and install macro code
  • maps:read read the learned map of an app

El servidor local escucha en loopback y solo responde a tu propio equipo: una petición desde otra máquina, o desde una página del navegador en otro origen, se rechaza. Funciona mientras la app está abierta, y lo apagas en el mismo sitio donde lo encendiste.

Preguntas frecuentes sobre el servidor MCP para Android

¿Qué es un servidor MCP para Android?

MCP (Model Context Protocol) es la forma en que los clientes de IA como Claude Code, Cursor y Codex llaman a herramientas externas. Un servidor MCP para Android expone un dispositivo Android como herramientas: hacer una captura, leer el texto que hay en ella, tocar, deslizar, escribir, abrir una app. El servidor de MAS expone 41 herramientas y añade lo que un servidor de dispositivo por sí solo no puede: ejecutar una macro guardada, pedirle a MAS Agent que construya una y leer el mapa que aprendió de una app.

¿Cómo conecto Claude Code a un emulador Android?

Para tu propio emulador, activa el servidor local en la app, en Integraciones (MCP), y registra su URL: claude mcp add --transport http mas-local http://127.0.0.1:3846/mcp. Controla cualquier dispositivo que adb pueda ver. Para un dispositivo en la nube, añade el servidor alojado con claude mcp add --transport http y después inicia sesión desde /mcp dentro de Claude Code o pasa tu clave en una cabecera. Los dos fragmentos están en esta página.

¿Funciona con BlueStacks, LDPlayer, MuMu, MEmu?

Sí. El servidor local habla con lo que liste adb devices, lo que cubre BlueStacks, LDPlayer, MuMu, MEmu y los demás emuladores compatibles con adb, en Windows o macOS. Nada en él está atado a una marca de emulador.

¿Cursor o Codex pueden controlar un emulador Android por MCP?

Sí. Cursor acepta los dos servidores como entradas HTTP en mcp.json: el alojado con tu clave en una cabecera, el local con su URL de loopback. Codex CLI añade el servidor alojado con codex mcp add y una clave desde una variable de entorno, y el servidor local con --url. Las mismas herramientas aparecen en cada uno.

¿Qué otros clientes MCP funcionan?

Cualquier cliente capaz de llamar a un servidor MCP por HTTP: Claude Code, Cursor, Codex, Hermes, OpenCode, Gemini CLI y otros. Claude Desktop y claude.ai añaden el servidor alojado como conector personalizado y te hacen iniciar sesión; para el servidor local, Claude Desktop arranca la propia app, porque lanza comandos en vez de llamar a URLs.

¿Necesito tener instalado ADB o Android Studio?

El servidor local controla el emulador por adb, y la app de escritorio trae su propia copia, así que no hay nada que instalar más allá de la app; Android Studio no hace falta. El servidor alojado no necesita instalar nada: los dispositivos en la nube se controlan en el servidor y tu cliente solo llama a herramientas.

¿El modelo puede ver la pantalla de verdad?

Sí. screenshot devuelve la pantalla como una imagen que el modelo mira directamente. read_text ejecuta OCR y devuelve cada línea con su confianza y su caja delimitadora, y find_image busca la plantilla que envías y devuelve la puntuación y las coordenadas que tocar. No hace falta ningún árbol de accesibilidad, por eso funciona en juegos.

¿Puedo controlar un teléfono Android físico conectado a mi PC?

Sí, a través del servidor local. Activa la depuración USB, conecta el teléfono y aparece en list_devices como cualquier emulador. Las herramientas de pantalla, entrada y visión funcionan igual.

¿Es un servidor MCP remoto o se ejecuta en local?

Ambas cosas. El servidor alojado es un único endpoint HTTP remoto, https://api.automationmacro.com/mcp, con las 41 herramientas para tus dispositivos en la nube. El servidor local es la propia app de escritorio, en http://127.0.0.1:3846/mcp, con 38 herramientas para emuladores y teléfonos conectados: las mismas herramientas de dispositivo, visión, macros, biblioteca de imágenes, creación, bucle de desarrollo y programación, salvo las reservas de dispositivo y los mapas de app. Lo que cambia es dónde se ejecuta el trabajo.

¿Cómo funciona la autenticación?

El servidor alojado usa la clave que creas en la app, con los alcances que marques, en una cabecera X-API-Key o Authorization: Bearer en cada petición. Un cliente que implemente la extensión de credenciales de cliente de MCP puede cambiarla por un token de una hora en https://api.automationmacro.com/api/mcp/oauth/token, y un cliente que inicia sesión de forma interactiva recibe sus propios tokens; al revocar la clave dejan de valer todos. Los documentos de descubrimiento se publican en /.well-known. El servidor local no lleva clave.

¿Qué devuelve author_macro y cuánto tarda?

Arranca una sesión de MAS Agent en un dispositivo en la nube y devuelve un id de sesión de inmediato. El agente explora la app durante varios minutos; get_agent_session transmite su transcripción con un cursor y muestra cualquier pregunta que haga, que respondes con answer_agent_session. Cuando termina, el id de la macro está en la sesión y la macro en tu biblioteca, lista para run_macro. Crearla gasta créditos de IA; ejecutar la macro terminada cuesta cero. Ver MAS Agent.

¿Es gratis? ¿Cuánto cuesta un dispositivo en la nube?

El servidor local forma parte de la app de escritorio sin coste adicional; necesita la app abierta y con la sesión iniciada. El servidor alojado forma parte de tu cuenta de MAS; sus herramientas de dispositivo funcionan en los dispositivos en la nube que tengas, $80/mes cada uno con la asignación mensual de créditos, y no hay cargo por llamada en las herramientas de dispositivo. Ejecutar una macro terminada cuesta cero créditos; la creación con el agente gasta créditos mientras trabaja. Ver precios.

¿Puede funcionar 24/7 en un dispositivo en la nube sin mi PC encendido?

Sí. lease_device abre una sesión de control en un dispositivo en la nube y puede arrancar uno detenido; run_macro se ejecuta en el servidor. Tu PC no tiene que quedarse encendido, y la reserva se renueva en cada llamada y caduca tras 10 minutos de inactividad. Ver dispositivos en la nube.

¿Puedo usarlo para pruebas y QA de apps Android?

Sí. Apunta un cliente a una build de pruebas, recorre el flujo con tap, type y press_key, comprueba cada pantalla con read_text o find_image, y deja que author_macro convierta un flujo que recorres una vez en una comprobación repetible. Automatiza la app a través de la pantalla como lo haría un usuario; no es un framework de pruebas unitarias.

Descargar la app Ver precios Documentación de configuración