Servidor MCP do MAS

Servidor MCP Android para Claude Code, Cursor, Codex e qualquer cliente MCP

41 ferramentas que dão ao seu cliente de IA olhos e mãos no Android: capturas de tela que ele enxerga, OCR e correspondência de modelo, toques, deslizes e digitação, execuções de macro e um agente que cria uma macro a partir de uma frase. Controle BlueStacks, LDPlayer, MuMu, MEmu ou qualquer emulador compatível com adb no Windows ou Mac, um celular conectado ao seu PC ou dispositivos Android na nuvem sempre ligados, a partir do cliente que você já usa.

O servidor hospedado com a sua chave MAS em um cabeçalho, depois o servidor local por URL enquanto o app estiver aberto.

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
Baixar o app Conheça o MAS Agent Documentação de configuração

O que é

O que o servidor MCP Android do MAS faz

MCP é o protocolo que clientes de IA usam para chamar ferramentas externas. Este servidor transforma um dispositivo Android nessas ferramentas. Seu cliente pede uma captura de tela e recebe uma imagem que consegue enxergar; pergunta o que a tela diz e recebe linhas de OCR com confiança e caixas; envia um modelo e recebe de volta onde ele está; toca, desliza, digita e pressiona teclas; abre e fecha apps. Essa é a parte que todo servidor MCP Android faz, e ela funciona do mesmo jeito em um emulador, em um celular conectado ou em um dispositivo na nuvem.

O servidor do MAS também faz a parte que um servidor de dispositivo não consegue. Ele lê e executa as macros da sua biblioteca, pede ao MAS Agent para explorar um app e devolver uma macro Python pronta, e expõe o mapa que o agente aprendeu daquele app, além da referência completa do SDK como recurso MCP para que seu cliente escreva código de macro no estilo da casa. Isso o torna um servidor MCP para automação Android na camada do dispositivo, e um servidor MCP de automação móvel nas camadas acima: macros, o agente, os mapas. Não é um plugin do Android Studio nem um assistente de código. Ele controla o dispositivo.

Servidor hospedado

Todas as 41 ferramentas, nos seus dispositivos na nuvem

Um endpoint HTTP remoto. Reserve um dispositivo na nuvem, controle-o, rode macros no servidor, crie novas com o agente, leia mapas de app. Nada para instalar, e seu PC pode ficar desligado.

Servidor local, no app

38 ferramentas, na sua máquina

O app de desktop é o servidor. Ative-o em Integrações (MCP) e aponte seu cliente para a URL de loopback. Ele controla tudo o que o adb enxerga, BlueStacks, LDPlayer, MuMu, MEmu no Windows ou macOS ou um celular com depuração USB, e traz junto a sua biblioteca de macros, a biblioteca de imagens, a criação pelo agente, o ciclo de desenvolvimento e o agendador.

Emuladores

Controle emuladores Android: BlueStacks, LDPlayer, MuMu, MEmu no Windows ou Mac

O servidor local é um servidor MCP para emulador Android, para o emulador que já está na sua mesa. Ative-o em Integrações (MCP), dentro do app, e aponte seu cliente para http://127.0.0.1:3846/mcp. Toda ferramenta de dispositivo aceita um device, o id que vem de list_devices, um serial do adb ou apenas a porta, e você pode omitir isso quando só um emulador está rodando. O app traz o próprio adb, então essa é a configuração de MCP com emulador Android que a maioria das pessoas procura: um botão para ativar, uma URL, pronto.

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

Jogos são o caso que quebra servidores baseados em árvore de acessibilidade: não há árvore para ler. Os dois servidores trabalham a partir dos pixels, então um modelo consegue jogar em uma tela de jogo do mesmo jeito que navega em uma tela de configurações.

Dispositivos na nuvem

Dispositivos Android na nuvem, nada para instalar

O servidor hospedado alcança os dispositivos sempre ligados que o MAS roda para você. lease_device abre uma sessão de controle e retorna o id de reserva de que toda ferramenta de dispositivo precisa; defina auto_start e ele inicia um dispositivo parado antes. A reserva se renova a cada chamada e expira depois de 10 minutos ociosos, então um cliente esquecido não consegue segurar um dispositivo para sempre. run_macro executa no dispositivo pelo servidor e author_macro coloca o MAS Agent para trabalhar nele, ambos com o seu PC desligado.

As ferramentas de dispositivo não têm cobrança por chamada; elas funcionam nos dispositivos na nuvem da sua conta, $80/mês cada com a franquia mensal de créditos. Ver dispositivos na nuvem.

Seu próprio celular

Um servidor MCP Android via ADB para o celular na sua mesa

Ative a depuração USB, conecte o celular, e o servidor local o lista ao lado dos seus emuladores. Todas as ferramentas de tela, entrada e visão funcionam nele: um modelo consegue controlar um celular Android por MCP do mesmo jeito que controla um emulador, a partir do cliente que você já usa, sem nada instalado no celular.

Visão

Capturas de tela que o modelo enxerga, OCR e correspondência de modelo

  • screenshot retorna a tela como conteúdo de imagem, então o modelo olha diretamente para ela em vez de adivinhar a partir de uma árvore. O servidor local a redimensiona por padrão para 1280 px no lado maior e informa o fator de escala.
  • read_text roda OCR na tela ou em uma região e retorna cada linha com uma confiança e uma caixa delimitadora, então "toque na palavra Resgatar" vira uma coordenada, não uma esperança.
  • find_image procura um modelo que você envia usando OpenCV, com um limiar que você controla, e retorna a pontuação e o centro para tocar.

Ferramentas

Todas as 41 ferramentas

Cada ferramenta pelo nome, com seus parâmetros. As ferramentas "local e hospedado" existem nas duas superfícies; as poucas que não, vêm marcadas com a superfície a que pertencem.

Device control

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

  • get_status local e hospedado
    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 e hospedado
    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) hospedado
    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) hospedado
    End the control session. The device keeps running.
  • tap (x, y) local e hospedado
    Tap the screen at device coordinates.
  • swipe (x1, y1, x2, y2, duration_ms) local e hospedado
    Swipe between two points for scrolling and flicks, with a chosen duration (default 300 ms).
  • long_press (x, y, duration_ms) local e hospedado
    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 e hospedado
    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 e hospedado
    Type text into the focused input field.
  • press_key (key) local e hospedado
    Press BACK, HOME, ENTER, TAB, DEL or any KEYCODE_ name.
  • open_app (package) local e hospedado
    Launch an app by package name.
  • close_app (package) local e hospedado
    Force-stop an app by package name.
  • current_app local e hospedado
    Report the package in the foreground.
  • screen_size local e hospedado
    Return the screen size in pixels, the coordinate space for tap and swipe.
  • wait (ms) local e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    List your saved macros with name, id and type (code, or legacy for a retired block macro).
  • get_macro_code (macro_id, file) local e hospedado
    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 e hospedado
    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) hospedado
    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 e hospedado
    Stop a running macro.
  • get_run_log (run_id, max_lines) local e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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) hospedado
    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 e hospedado
    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 e hospedado
    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 e hospedado
    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 o servidor publica para que um cliente escreva código de macro sem sair da conversa.

  • 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.

Configuração

Adicione em um minuto

O servidor hospedado usa a sua chave em toda requisição: crie uma no app, em Integrações (MCP) ou em Chaves de API, marque os escopos que quiser e envie-a em um cabeçalho X-API-Key ou Authorization. Um cliente que prefira uma credencial de curta duração pode trocar a chave por um token de acesso que dura 1 hora, e um cliente que faz login interativo recebe os próprios tokens. O servidor local não precisa de chave nenhuma. 

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

O servidor hospedado com a sua chave em um cabeçalho, depois o servidor local por URL enquanto o app estiver aberto:

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

Em .cursor/mcp.json, os dois 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

Em ~/.codex/config.toml, com a chave em uma variável de ambiente; o servidor local é 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 e os demais

Qualquer cliente que aceite um servidor HTTP com cabeçalho. O Claude Desktop inicia um comando em vez disso, então ele recebe o próprio app como ponte para o servidor local; o app mostra o bloco já com o seu caminho de instalação.

{
  "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" }
  }
}

Verifique: peça ao seu cliente para listar os dispositivos, depois uma captura de tela. Endpoint https://api.automationmacro.com/mcp, protocolo 2025-06-18, documentos de descoberta em /.well-known.

O agente, como ferramenta

author_macro: de uma exploração por IA a uma macro Python pronta

A maioria dos servidores MCP Android para no dispositivo. Este entrega o agente. author_macro recebe um objetivo em linguagem comum e um dispositivo na nuvem e inicia uma sessão do MAS Agent que explora o app, captura as imagens de modelo e regiões de texto de que precisa da tela ao vivo, compila uma macro Python determinística e a valida por repetição. get_agent_session retorna a transcrição com um cursor e qualquer pergunta que o agente fez; answer_agent_session responde. A macro pronta entra na sua biblioteca com seu id na sessão, pronta para run_macro, e cada execução depois disso custa zero créditos de IA. Conheça o MAS Agent.

QA

Testes de apps Android e fluxos de QA

Aponte um cliente para uma build de teste em um emulador ou dispositivo na nuvem, percorra o fluxo com tap, type_text e press_key, e verifique cada tela com read_text ou find_image. Percorra o fluxo uma vez com author_macro e ele vira uma verificação repetível que você pode agendar. Ele testa o app pela tela como um usuário faz; não é um framework de testes unitários.

Segurança

Servidor remoto, transporte HTTP, chaves com escopo e um servidor local que só responde à sua máquina

O servidor hospedado é JSON-RPC sem estado sobre HTTPS em um único endpoint. As chaves são criadas no app, exibidas uma vez, podem ter data de validade e são revogadas com um clique; os tokens gerados a partir delas duram 1 hora e morrem junto com a chave. Cada chave carrega apenas os escopos que você concede:

  • 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

O servidor local escuta em loopback e só responde à sua própria máquina: uma requisição de outra máquina, ou de uma página do navegador em outra origem, é recusada. Ele roda enquanto o app está aberto, e você desliga no mesmo lugar em que ligou.

Perguntas frequentes sobre o servidor MCP Android

O que é um servidor MCP Android?

MCP (Model Context Protocol) é como clientes de IA como Claude Code, Cursor e Codex chamam ferramentas externas. Um servidor MCP Android expõe um dispositivo Android como ferramentas: tirar uma captura de tela, ler o texto nela, tocar, deslizar, digitar, abrir um app. O servidor do MAS expõe 41 ferramentas e adiciona o que um servidor de dispositivo sozinho não consegue: rodar uma macro salva, pedir ao MAS Agent para criar uma e ler o mapa que ele aprendeu de um app.

Como conecto o Claude Code a um emulador Android?

Para o seu próprio emulador, ative o servidor local no app, em Integrações (MCP), e registre a URL dele: claude mcp add --transport http mas-local http://127.0.0.1:3846/mcp. Ele controla qualquer dispositivo que o adb enxerga. Para um dispositivo na nuvem, adicione o servidor hospedado com claude mcp add --transport http e depois faça login em /mcp dentro do Claude Code ou passe a sua chave em um cabeçalho. Os dois trechos estão nesta página.

Funciona com BlueStacks, LDPlayer, MuMu, MEmu?

Sim. O servidor local fala com o que adb devices listar, o que cobre BlueStacks, LDPlayer, MuMu, MEmu e os outros emuladores compatíveis com adb, no Windows ou macOS. Nada nele é preso a uma marca de emulador.

O Cursor ou o Codex podem controlar um emulador Android por MCP?

Sim. O Cursor aceita os dois servidores como entradas HTTP em mcp.json: o hospedado com a sua chave em um cabeçalho, o local com a URL de loopback dele. O Codex CLI adiciona o servidor hospedado com codex mcp add e uma chave vinda de uma variável de ambiente, e o servidor local com --url. As mesmas ferramentas aparecem em cada um.

Quais outros clientes MCP funcionam?

Qualquer cliente que consiga chamar um servidor MCP por HTTP: Claude Code, Cursor, Codex, Hermes, OpenCode, Gemini CLI e outros. O Claude Desktop e o claude.ai adicionam o servidor hospedado como conector personalizado e pedem o seu login; para o servidor local, o Claude Desktop inicia o próprio app, porque ele executa comandos em vez de chamar URLs.

Preciso ter ADB ou Android Studio instalado?

O servidor local controla o emulador pelo adb, e o app de desktop traz a própria cópia, então não há nada para instalar além do app; o Android Studio não é necessário. O servidor hospedado não precisa de nada instalado: os dispositivos na nuvem são controlados no servidor e seu cliente apenas chama ferramentas.

O modelo realmente enxerga a tela?

Sim. screenshot retorna a tela como uma imagem que o modelo olha diretamente. read_text roda OCR e retorna cada linha com uma confiança e uma caixa delimitadora, e find_image procura um modelo que você envia e retorna a pontuação e as coordenadas para tocar. Não precisa de árvore de acessibilidade, e é por isso que funciona em jogos.

Posso controlar um celular Android físico conectado ao meu PC?

Sim, pelo servidor local. Ative a depuração USB, conecte o celular, e ele aparece em list_devices como qualquer emulador. As ferramentas de tela, entrada e visão funcionam do mesmo jeito.

É um servidor MCP remoto ou roda localmente?

Os dois. O servidor hospedado é um endpoint HTTP remoto, https://api.automationmacro.com/mcp, com todas as 41 ferramentas para os seus dispositivos na nuvem. O servidor local é o próprio app de desktop, em http://127.0.0.1:3846/mcp, com 38 ferramentas para emuladores e celulares conectados: as mesmas ferramentas de dispositivo, visão, macro, biblioteca de imagens, criação, ciclo de desenvolvimento e agendamento, menos as reservas de dispositivo e os mapas de app. O que muda é onde o trabalho roda.

Como funciona a autenticação?

O servidor hospedado usa a chave que você cria no app, com os escopos que marcar, em um cabeçalho X-API-Key ou Authorization: Bearer em toda requisição. Um cliente que implemente a extensão de credenciais de cliente do MCP pode trocá-la por um token de uma hora em https://api.automationmacro.com/api/mcp/oauth/token, e um cliente que faz login interativo recebe os próprios tokens; revogar a chave derruba todos eles. Os documentos de descoberta são publicados em /.well-known. O servidor local não tem chave.

O que author_macro retorna e quanto tempo leva?

Ele inicia uma sessão do MAS Agent em um dispositivo na nuvem e retorna um id de sessão na hora. O agente explora o app por vários minutos; get_agent_session transmite a transcrição com um cursor e mostra qualquer pergunta que ele fizer, que você responde com answer_agent_session. Quando termina, o id da macro está na sessão e a macro está na sua biblioteca, pronta para run_macro. A criação gasta créditos de IA; rodar a macro pronta custa zero. Conheça o MAS Agent.

É grátis? Quanto custa um dispositivo na nuvem?

O servidor local faz parte do app de desktop, sem custo adicional; ele precisa do app aberto e com login feito. O servidor hospedado faz parte da sua conta MAS; suas ferramentas de dispositivo funcionam nos dispositivos na nuvem que você possui, $80/mês cada com a franquia mensal de créditos, e não há cobrança por chamada nas ferramentas de dispositivo. Rodar uma macro pronta custa zero créditos; a criação pelo agente gasta créditos enquanto trabalha. Ver preços.

Pode rodar 24 horas em um dispositivo na nuvem sem o meu PC ligado?

Sim. lease_device abre uma sessão de controle em um dispositivo na nuvem e pode iniciar um que esteja parado; run_macro executa no servidor. Seu PC não precisa ficar ligado, e a reserva se renova a cada chamada e expira depois de 10 minutos ociosos. Ver dispositivos na nuvem.

Posso usar para testes de apps Android e QA?

Sim. Aponte um cliente para uma build de teste, percorra o fluxo com tap, type e press_key, verifique cada tela com read_text ou find_image, e deixe author_macro transformar um fluxo que você percorre uma vez em uma verificação repetível. Ele automatiza o app pela tela como um usuário faz; não é um framework de testes unitários.

Baixar o app Ver preços Documentação de configuração