Applitools MCP server
2026년 11월 12일 커밋IDE 내에서 Applitools Eyes를 사용하여 AI 어시스턴트가 시각적 테스트를 생성, 업데이트, 검토 및 해결할 수 있도록 지원합니다.
다른 이름 applitools/mcp, mcp, @applitools/mcp
- 스타
- 0
- Tools
- 22
- 다운로드, 30일
- 4,951
- 최신 버전
- 1.0.17
- 마지막 커밋
- 2026년 11월 12일
- 라이선스
- —
Applitools MCP란?
IDE 내에서 Applitools Eyes를 사용하여 AI 어시스턴트가 시각적 테스트를 생성, 업데이트, 검토 및 해결할 수 있도록 지원합니다. 22개 도구를 제공합니다. 예: eyes_verify_api_key, eyes_setup_project, eyes_setup_ufg.
프로젝트 README에서 생성된 요약
Applitools MCP server 정보
이 MCP server는 개발자와 QA 엔지니어가 AI 어시스턴트를 통해 시각적 회귀 테스트를 관리할 수 있게 해줍니다. Cursor, Claude Code 또는 GitHub Copilot과 같은 클라이언트에 연결하면 IDE를 벗어나지 않고도 Applitools Eyes를 사용하여 시각적 테스트를 생성, 업데이트 및 해결할 수 있습니다. 특히 Eyes SDK를 처음 설정하는 엔지니어나 대량의 테스트 실패 건을 빠르게 분류해야 하는 팀에 유용합니다.
설정 및 체크포인트 도구는 현재 Playwright Fixtures SDK를 지원하며, 검사 및 해결 도구는 사용 언어와 관계없이 모든 Eyes 테스트 결과와 함께 작동합니다. 이 기능을 사용하려면 실행 API key와 함께 테스트 데이터 검사 및 해결을 위한 읽기 전용 및 쓰기 전용 key를 각각 제공해야 합니다. 이 server는 Node.js를 통해 로컬에서 실행되며, VS Code extension을 통해 설치하거나 MCP client 설정에서 수동으로 구성할 수 있습니다.
활용 사례
- 1Playwright 시각적 테스트 설정 자동화AI 어시스턴트에게 Eyes reporter를 구성하고 기존 Playwright 테스트에 시각적 체크포인트를 추가하도록 요청하세요.
- 2교차 브라우저 테스트 구성어시스턴트를 통해 Ultrafast Grid를 설정하여 여러 브라우저와 기기에서 동시에 테스트를 수행할 수 있습니다.
- 3시각적 테스트 실패 조사실패한 테스트 모음을 분석하여 정확히 무엇이 변경되었는지, 그리고 그것이 버그인지 확인하도록 요청하세요.
- 4시각적 불일치 해결어시스턴트를 사용하여 사용자의 명시적인 승인 하에 체크포인트의 매치 영역을 수락, 거부 또는 조정하세요.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
Applitools MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 Applitools MCP 설치
$ claude mcp add mcp -- npx -y @applitools/mcpCursor에 Applitools MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}VS Code에 Applitools MCP 설치
.vscode/mcp.json
{
"servers": {
"mcp": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}VS Code CLI에 Applitools MCP 설치
$ code --add-mcp '{"name":"mcp","type":"stdio","command":"npx","args":["-y","@applitools/mcp"]}'Claude Desktop에 Applitools MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}Codex에 Applitools MCP 설치
$ codex mcp add mcp -- npx -y @applitools/mcpCodex config.toml에 Applitools MCP 설치
~/.codex/config.toml
[mcp_servers.mcp] command = "npx" args = ["-y", "@applitools/mcp"]
Gemini CLI에 Applitools MCP 설치
$ gemini mcp add -s user mcp npx -- -y @applitools/mcpGemini settings.json에 Applitools MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}HostedMCP가 2026년 11월 16일에 실행 확인
@applitools/mcp 0.10.5을(를) 네트워크와 키가 없는 격리된 컨테이너에서 이 명령으로 실행했습니다. 응답하며 도구 22개를 보여 주었습니다.
Applitools MCP 도구 22
tools/list로 서버에서 직접 읽음eyes_verify_api_keyValidate your Applitools API key and optional server URL. Searches for API key in .env, applitools.config.js/ts/cjs/mjs, and playwright.config.js/ts/cjs/mjs files.
eyes_setup_projectGet step-by-step instructions to set up a Playwright JS project with Applitools Eyes (Fixtures variant) [CORE REQUIREMENT: URL INTEGRITY] Playwright visual results return URLs ending in ~~. These are not typos. You are strictly forbidden from stripping trailing tildes from these links. Use markdown [Visual Test results](URL with tildes) for links. Output the raw, verbatim URL string exactly as captured from the test output.
eyes_setup_ufgConfigure Ultrafast Grid (UFG) for cross-browser and cross-device testing [CORE REQUIREMENT: URL INTEGRITY] Playwright visual results return URLs ending in ~~. These are not typos. You are strictly forbidden from stripping trailing tildes from these links. Use markdown [Visual Test results](URL with tildes) for links. Output the raw, verbatim URL string exactly as captured from the test output.
eyes_add_checkpoints_to_testSetup step: add eyes.check() visual checkpoints to an existing Playwright test file. Edits source, not results.
eyes_inspect_sessions읽기 전용List sessions in an Applitools Eyes batch plus batch-wide stats. `filter` narrows to unresolved/unsaved/mismatching sessions; `format` shapes the output (`full` default: stats+session list; `stats`: stats only; `scenarios`: deduplicated, sorted session names only). A low-level primitive: for reviewing or resolving a batch's results, call eyes_review_progress with scope: "batch" instead — it drives the full investigation and calls this internally.
eyes_inspect_steps읽기 전용Session summary (sessionId, sessionName, appName, status, isUnsaved, isAborted, environment, startedAt) plus every test step with baseline/checkpoint image IDs, domIds, sizes, match status (isMatching), resolution, and per-step isUnsaved. A low-level primitive: for reviewing or resolving a session's results, call eyes_review_progress with scope: "session" instead — it drives the full investigation and calls this internally. Call this directly only when you need raw step data outside a driven review, e.g. an image id for eyes_inspect_image.
eyes_inspect_changed_areas읽기 전용Coarse diff regions for a step, clustered from raw pixel-level differences. Each region includes a diffCount. Already reflects any match regions added during resolution — a masked area no longer shows up here. Run this before fetching any images or DOM data for a step. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again. A low-level primitive: for a driven step-level review, call eyes_review_progress with scope: "step" instead — it calls this internally for every changed area.
eyes_inspect_image_diff읽기 전용Export the checkpoint screenshot with visual differences highlighted in pink, cropped to `rect` if provided. Returns a file path — pass it directly to the Read tool to view the image. Pad a changed-area rect by 10px on every side before requesting it here; the region may exceed the image bounds, which is fine. Already reflects any match regions added during resolution — a masked area is no longer highlighted. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again.
eyes_inspect_image읽기 전용Export a baseline or checkpoint screenshot as a PNG, cropped to `rect` if provided. `imageId` comes from eyes_inspect_steps (baseline.id or checkpoint.id per step). Returns a file path, self-identifying by imageId and crop rect — pass it directly to the Read tool.
eyes_inspect_evidence읽기 전용Everything needed to review a step's changed areas, in one call: for each area, the image diff (checkpoint with differences highlighted in pink) plus the baseline and checkpoint screenshots, fetched together. Pass EVERY area you still have to review in a single call's `areaRects` — one call per area is exactly what this tool exists to avoid. Pass each rect exactly as eyes_review_progress gave it to you — do NOT pad it, the server pads it and clamps it to each image. Prefer this over calling eyes_inspect_image_diff and eyes_inspect_image separately; it is what eyes_review_diff_report's gate checks for. It also returns the whole step's structural DOM diff under `domDiff` and the match regions currently in effect under `regions`, so do not call eyes_inspect_dom_diff or eyes_inspect_regions separately for this step — the one exception is a `domDiff` or `regions` reporting `status: "computing"` or `status: "error"` (with the failure's own message under `error`), whose own `next` says where to pick it up. The composed `domDiff` waits only briefly, so `status: "computing"` is common and expected here — the images ship without waiting for it; follow its `next` to eyes_inspect_dom_diff, which is where the diff is waited out. Returns `evidence`, one entry per area in the order asked for, each with a labelled file path per image, plus the images themselves for clients that render them — read each `path` only for an image whose `inline` is false, and `notInlined` says why it was not. Inlined images arrive as image blocks in the same order as the `inline: true` entries, reading `evidence` top to bottom; `inlining` reports how much of the budget the response spent. Each image carries the `rect` it was actually cropped at: the two sides of a step can differ in size, so the crops are near-identical but NOT guaranteed equal — compare by content, and check the rects before reading anything into a difference in position or extent. Any image this step cannot produce for an area is listed under that area's `unavailable` with the reason, which is a fact about the step, not a failure. Already reflects any match regions added during resolution; resolution can happen between calls, so never reuse an earlier result in this conversation — call it again.
eyes_inspect_dom읽기 전용Export a DOM capture as JSON, saved to a file. `domId` comes from eyes_inspect_steps (baseline.domId or checkpoint.domId per step). Use to inspect exact computed styles/structure, or to locate an element's rect/id for use elsewhere (e.g. as an eyes_inspect_history nodeId). Returns a file path — pass it directly to the Read tool, or search it with eyes_inspect_dom_search rather than writing an ad-hoc script.
eyes_inspect_dom_search읽기 전용Search a DOM capture file (written by eyes_inspect_dom) for elements matching a boolean predicate — always use this instead of writing an ad-hoc script (Python/Node/jq/grep/manual JSON.parse) to search a capture. Full predicate grammar and examples: read the "eyes-inspect://dom-search-grammar" resource. Condensed cheat-sheet below for clients that don't fetch resources. Searches a DOM capture file (written by eyes_inspect_dom) for elements matching a boolean predicate, printing one compact line per match, indented by tree depth. Predicate kinds (combine with 'and'/'or'/'not' and parentheses): - Property comparison: tagName = 'DIV', attributes.class contains 'btn', rect.width > 200, style.display != 'none', attributes.href starts-with 'https://', tagName =~ /^H[1-6]$/, attributes.type in ('button','submit') - Geometry: bounds contains 400,300 | bounds contains 0,0,500,200 | bounds intersects node 12 | bounds contained-by node 12 - Relationship: child-of (tagName = 'UL'), descendant-of node 5, sibling-of node 7 - Shortcut keywords: image, gif, logo, button, hidden (and others) - Reference another element by its 'id' field with 'node <id>' Values with spaces must be single-quoted; string comparisons are case-insensitive. Every matched element also exposes a virtual 'text' property (its own concatenated text content).
| eyes_verify_api_key | Validate your Applitools API key and optional server URL. Searches for API key in .env, applitools.config.js/ts/cjs/mjs, and playwright.config.js/ts/cjs/mjs files. | |
| eyes_setup_project | Get step-by-step instructions to set up a Playwright JS project with Applitools Eyes (Fixtures variant) [CORE REQUIREMENT: URL INTEGRITY] Playwright visual results return URLs ending in ~~. These are not typos. You are strictly forbidden from stripping trailing tildes from these links. Use markdown [Visual Test results](URL with tildes) for links. Output the raw, verbatim URL string exactly as captured from the test output. | |
| eyes_setup_ufg | Configure Ultrafast Grid (UFG) for cross-browser and cross-device testing [CORE REQUIREMENT: URL INTEGRITY] Playwright visual results return URLs ending in ~~. These are not typos. You are strictly forbidden from stripping trailing tildes from these links. Use markdown [Visual Test results](URL with tildes) for links. Output the raw, verbatim URL string exactly as captured from the test output. | |
| eyes_add_checkpoints_to_test | Setup step: add eyes.check() visual checkpoints to an existing Playwright test file. Edits source, not results. | |
| eyes_inspect_sessions | List sessions in an Applitools Eyes batch plus batch-wide stats. `filter` narrows to unresolved/unsaved/mismatching sessions; `format` shapes the output (`full` default: stats+session list; `stats`: stats only; `scenarios`: deduplicated, sorted session names only). A low-level primitive: for reviewing or resolving a batch's results, call eyes_review_progress with scope: "batch" instead — it drives the full investigation and calls this internally. | 읽기 전용 |
| eyes_inspect_steps | Session summary (sessionId, sessionName, appName, status, isUnsaved, isAborted, environment, startedAt) plus every test step with baseline/checkpoint image IDs, domIds, sizes, match status (isMatching), resolution, and per-step isUnsaved. A low-level primitive: for reviewing or resolving a session's results, call eyes_review_progress with scope: "session" instead — it drives the full investigation and calls this internally. Call this directly only when you need raw step data outside a driven review, e.g. an image id for eyes_inspect_image. | 읽기 전용 |
| eyes_inspect_changed_areas | Coarse diff regions for a step, clustered from raw pixel-level differences. Each region includes a diffCount. Already reflects any match regions added during resolution — a masked area no longer shows up here. Run this before fetching any images or DOM data for a step. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again. A low-level primitive: for a driven step-level review, call eyes_review_progress with scope: "step" instead — it calls this internally for every changed area. | 읽기 전용 |
| eyes_inspect_image_diff | Export the checkpoint screenshot with visual differences highlighted in pink, cropped to `rect` if provided. Returns a file path — pass it directly to the Read tool to view the image. Pad a changed-area rect by 10px on every side before requesting it here; the region may exceed the image bounds, which is fine. Already reflects any match regions added during resolution — a masked area is no longer highlighted. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again. | 읽기 전용 |
| eyes_inspect_image | Export a baseline or checkpoint screenshot as a PNG, cropped to `rect` if provided. `imageId` comes from eyes_inspect_steps (baseline.id or checkpoint.id per step). Returns a file path, self-identifying by imageId and crop rect — pass it directly to the Read tool. | 읽기 전용 |
| eyes_inspect_evidence | Everything needed to review a step's changed areas, in one call: for each area, the image diff (checkpoint with differences highlighted in pink) plus the baseline and checkpoint screenshots, fetched together. Pass EVERY area you still have to review in a single call's `areaRects` — one call per area is exactly what this tool exists to avoid. Pass each rect exactly as eyes_review_progress gave it to you — do NOT pad it, the server pads it and clamps it to each image. Prefer this over calling eyes_inspect_image_diff and eyes_inspect_image separately; it is what eyes_review_diff_report's gate checks for. It also returns the whole step's structural DOM diff under `domDiff` and the match regions currently in effect under `regions`, so do not call eyes_inspect_dom_diff or eyes_inspect_regions separately for this step — the one exception is a `domDiff` or `regions` reporting `status: "computing"` or `status: "error"` (with the failure's own message under `error`), whose own `next` says where to pick it up. The composed `domDiff` waits only briefly, so `status: "computing"` is common and expected here — the images ship without waiting for it; follow its `next` to eyes_inspect_dom_diff, which is where the diff is waited out. Returns `evidence`, one entry per area in the order asked for, each with a labelled file path per image, plus the images themselves for clients that render them — read each `path` only for an image whose `inline` is false, and `notInlined` says why it was not. Inlined images arrive as image blocks in the same order as the `inline: true` entries, reading `evidence` top to bottom; `inlining` reports how much of the budget the response spent. Each image carries the `rect` it was actually cropped at: the two sides of a step can differ in size, so the crops are near-identical but NOT guaranteed equal — compare by content, and check the rects before reading anything into a difference in position or extent. Any image this step cannot produce for an area is listed under that area's `unavailable` with the reason, which is a fact about the step, not a failure. Already reflects any match regions added during resolution; resolution can happen between calls, so never reuse an earlier result in this conversation — call it again. | 읽기 전용 |
| eyes_inspect_dom | Export a DOM capture as JSON, saved to a file. `domId` comes from eyes_inspect_steps (baseline.domId or checkpoint.domId per step). Use to inspect exact computed styles/structure, or to locate an element's rect/id for use elsewhere (e.g. as an eyes_inspect_history nodeId). Returns a file path — pass it directly to the Read tool, or search it with eyes_inspect_dom_search rather than writing an ad-hoc script. | 읽기 전용 |
| eyes_inspect_dom_search | Search a DOM capture file (written by eyes_inspect_dom) for elements matching a boolean predicate — always use this instead of writing an ad-hoc script (Python/Node/jq/grep/manual JSON.parse) to search a capture. Full predicate grammar and examples: read the "eyes-inspect://dom-search-grammar" resource. Condensed cheat-sheet below for clients that don't fetch resources. Searches a DOM capture file (written by eyes_inspect_dom) for elements matching a boolean predicate, printing one compact line per match, indented by tree depth. Predicate kinds (combine with 'and'/'or'/'not' and parentheses): - Property comparison: tagName = 'DIV', attributes.class contains 'btn', rect.width > 200, style.display != 'none', attributes.href starts-with 'https://', tagName =~ /^H[1-6]$/, attributes.type in ('button','submit') - Geometry: bounds contains 400,300 | bounds contains 0,0,500,200 | bounds intersects node 12 | bounds contained-by node 12 - Relationship: child-of (tagName = 'UL'), descendant-of node 5, sibling-of node 7 - Shortcut keywords: image, gif, logo, button, hidden (and others) - Reference another element by its 'id' field with 'node <id>' Values with spaces must be single-quoted; string comparisons are case-insensitive. Every matched element also exposes a virtual 'text' property (its own concatenated text content). | 읽기 전용 |
도구 22개 모두 보기도구 수 줄이기
eyes_inspect_dom_diff읽기 전용Structural DOM diff between a step's baseline and checkpoint. `rect`, if given, only filters the output, not the comparison itself. Entries are tagged `changed`/`new`/`missing`/`displaced`. Already omits any structural difference that doesn't correspond to an actual visual diff under the step's current match settings/regions — masking a change elsewhere no longer produces DOM-diff noise. Always run this for a step before concluding a visual diff is rendering noise, and before summarizing large diffs (which are often caused by displacement — this reveals the root cause directly). The diff is computed server-side and this call may take up to ~20 seconds before responding — that is normal, do not abort early; if the call is interrupted anyway, the computation continues server-side — call this tool again with the same arguments and it resumes, usually instantly. A large diff can outlive the wait budget, in which case the result is `{"status":"computing","taskId",...}` instead of the diff — always follow its `next` field exactly (re-call this tool with the same arguments plus that taskId); the diff is ONLY available through that follow-up call, never by inferring it from images or prior context. If a diff here is the exact same underlying change you've already recorded elsewhere in this scenario, eyes_review_diff_report's `sameAs` argument lets you skip straight to reviewing just the checkpoint image for it. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again.
eyes_inspect_regions읽기 전용The match regions currently in effect for a step (ignore/strict/layout/dynamic/etc.), optionally filtered to those intersecting `rect` on either side. Returns `{ regions, codedRegions }`: `regions` are the regions defined on the step's baseline, or changed by a reviewer through resolution (a domSelector present on one side but empty on the other means that side's anchor is stale, or its target genuinely doesn't exist there); `codedRegions` are regions provided by the test code itself, keyed by regionId instead.
eyes_inspect_history읽기 전용For each given node id, a changelog of non-empty diffs against prior runs of the same test scenario and environment, keyed by node id. Use before concluding whether a changed or drifted element is dynamic (recurring changes) versus a one-time real change — never guess this from a single run alone. An empty array for a node means no change was found across however much history was searched; that alone is not proof of anything either way. Each historic comparison is computed server-side, so this call can take up to ~20 seconds per comparison — do not abort early; if the call is interrupted or reports a still-computing comparison, call it again with the same arguments and the walk resumes from cache.
eyes_resolve_checkpointMarks a step's checkpoint image as accepted or rejected, per `action` — see its own description for what each one does to the baseline. Only call this once the step's differences have actually been investigated and judged (see the eyes_inspect_* tools). By default also accepts (or rejects) every other still-unresolved step that genuinely shares this step's diff, across this session and same-scenario siblings — see propagate; a candidate that already has its own accept/reject decision is left alone. A low-level primitive: for a driven review that also resolves what it finds, use eyes_review_progress with mode: "resolve" instead — it calls this deterministically from its own findings. Call this directly only for a one-off manual decision outside that review.
eyes_resolve_regionsAdds/removes/updates a step's ignore or match regions, with every regionOp's ids/rects read against the BASELINE or CHECKPOINT image/DOM per `target` (mapped onto whichever side the step's current resolution actually needs). Does not itself change accept/reject. Propagates by default (see propagate) since masking confirmed-dynamic content applies regardless of a sibling's own accept/reject verdict. Returns one entry per touched step, each listing the regions actually changed by each input regionOp (a clear op is reported as the concrete regions it removed). A low-level primitive: for a driven review that also resolves what it finds, use eyes_review_progress with mode: "resolve" instead — it calls this deterministically from its own findings. Call this directly only for a one-off manual fix outside that review.
eyes_resolve_saveSaves every accepted/rejected step and region change in the WHOLE BATCH to the baseline — all of its tests, not just the session in the URL (the server save is batch-scoped; the session part only identifies the batch). A potentially destructive, hard-to-reverse operation. Only call it once the user has explicitly approved committing the changes just made.
eyes_resolve_resetRestores every in-scope session's baseline to the revision the test originally ran against, and clears any pending (unsaved) accept/reject/region resolution back to unresolved. Unlike every other eyes_resolve_*/eyes_inspect_* tool, the URL's shape is not just a locator — it IS the scope: a session URL (even with a /steps/N suffix) resets only that one session, while a bare batch URL resets every session in the batch. If the user asks to reset "the batch"/"everything"/"all sessions" but only a session or step URL is on hand (e.g. reused from an earlier call in this conversation), strip it down to the bare batch form first — passing the session URL as-is will silently under-scope the reset. Destructive and not undoable — only call it with explicit user approval of that exact scope.
eyes_review_progressTracks progress investigating whatever `scope` names — see its own description for what each one investigates and which arguments it takes. ALWAYS call this to initiate test results inspection at that level, and ALWAYS follow its `next` field for what to call next. Do not report findings or conclusions to the user before this review's own eyes_review_end call reports completion. In mode "resolve" this additionally acts on what it finds: dynamic content is masked with a match region as each diff is reported, and each step is accepted/rejected/left-unresolved deterministically from its own findings — the response's top-level `resolution` and `regions` tallies, plus each finding's own `regions` detail, report exactly what happened.
eyes_review_endRecords the deduplicated findings summary for whatever `scope` names, once eyes_review_progress for that same scope reports every one of its children reviewed — see `scope`'s own description for what each one records, and `findings` for the shape each one takes. Discarded (not an error) if called too early. Always follow the returned `next` field — it tells you exactly what to do, whether that means retrying via eyes_review_progress, reviewing another entity at this same level, moving up to the level above, or the investigation is now fully reviewed.
eyes_review_diff_reportRecords the rich per-diff evidence for the changed areas of one step — one `reports` entry per area, every unreviewed area of the step in a single call, and every finding fully specified for its claimed category. Each entry is verified on its own, against its own areaRect: it hard-throws if eyes_inspect_evidence wasn't actually fetched for that areaRect, a finding claims dynamic.justification:"History" with no matching eyes_inspect_history call, a finding proposes a dynamic.mask fix with no eyes_inspect_regions call for this step, its mask's `before` doesn't match a region actually in effect right now, or its mask's `after` doesn't cover the finding's own area. Entries are processed in order and stop at the first rejection — the ones before it stay recorded, and the error names exactly which areas to send back. If an area is the exact same underlying change as an area already recorded in the same scenario, set its entry's `sameAs` instead of redoing the full trio — see its own description. In mode "resolve" each finding's `dynamic.mask` is turned into an actual checkpoint match-region change right here — `mask.after.area`, if left null/omitted, defaults to the finding's own `area` — and the response reports per finding what was added/adjusted (or why it could not be), on `regions` and appended to `description`. Always follow the returned `next` field — it tells you exactly what to do next, whether that's reporting more changed areas or moving up to the step level.
| eyes_inspect_dom_diff | Structural DOM diff between a step's baseline and checkpoint. `rect`, if given, only filters the output, not the comparison itself. Entries are tagged `changed`/`new`/`missing`/`displaced`. Already omits any structural difference that doesn't correspond to an actual visual diff under the step's current match settings/regions — masking a change elsewhere no longer produces DOM-diff noise. Always run this for a step before concluding a visual diff is rendering noise, and before summarizing large diffs (which are often caused by displacement — this reveals the root cause directly). The diff is computed server-side and this call may take up to ~20 seconds before responding — that is normal, do not abort early; if the call is interrupted anyway, the computation continues server-side — call this tool again with the same arguments and it resumes, usually instantly. A large diff can outlive the wait budget, in which case the result is `{"status":"computing","taskId",...}` instead of the diff — always follow its `next` field exactly (re-call this tool with the same arguments plus that taskId); the diff is ONLY available through that follow-up call, never by inferring it from images or prior context. If a diff here is the exact same underlying change you've already recorded elsewhere in this scenario, eyes_review_diff_report's `sameAs` argument lets you skip straight to reviewing just the checkpoint image for it. Resolution can happen between calls, so never reuse an earlier result in this conversation — call it again. | 읽기 전용 |
| eyes_inspect_regions | The match regions currently in effect for a step (ignore/strict/layout/dynamic/etc.), optionally filtered to those intersecting `rect` on either side. Returns `{ regions, codedRegions }`: `regions` are the regions defined on the step's baseline, or changed by a reviewer through resolution (a domSelector present on one side but empty on the other means that side's anchor is stale, or its target genuinely doesn't exist there); `codedRegions` are regions provided by the test code itself, keyed by regionId instead. | 읽기 전용 |
| eyes_inspect_history | For each given node id, a changelog of non-empty diffs against prior runs of the same test scenario and environment, keyed by node id. Use before concluding whether a changed or drifted element is dynamic (recurring changes) versus a one-time real change — never guess this from a single run alone. An empty array for a node means no change was found across however much history was searched; that alone is not proof of anything either way. Each historic comparison is computed server-side, so this call can take up to ~20 seconds per comparison — do not abort early; if the call is interrupted or reports a still-computing comparison, call it again with the same arguments and the walk resumes from cache. | 읽기 전용 |
| eyes_resolve_checkpoint | Marks a step's checkpoint image as accepted or rejected, per `action` — see its own description for what each one does to the baseline. Only call this once the step's differences have actually been investigated and judged (see the eyes_inspect_* tools). By default also accepts (or rejects) every other still-unresolved step that genuinely shares this step's diff, across this session and same-scenario siblings — see propagate; a candidate that already has its own accept/reject decision is left alone. A low-level primitive: for a driven review that also resolves what it finds, use eyes_review_progress with mode: "resolve" instead — it calls this deterministically from its own findings. Call this directly only for a one-off manual decision outside that review. | |
| eyes_resolve_regions | Adds/removes/updates a step's ignore or match regions, with every regionOp's ids/rects read against the BASELINE or CHECKPOINT image/DOM per `target` (mapped onto whichever side the step's current resolution actually needs). Does not itself change accept/reject. Propagates by default (see propagate) since masking confirmed-dynamic content applies regardless of a sibling's own accept/reject verdict. Returns one entry per touched step, each listing the regions actually changed by each input regionOp (a clear op is reported as the concrete regions it removed). A low-level primitive: for a driven review that also resolves what it finds, use eyes_review_progress with mode: "resolve" instead — it calls this deterministically from its own findings. Call this directly only for a one-off manual fix outside that review. | |
| eyes_resolve_save | Saves every accepted/rejected step and region change in the WHOLE BATCH to the baseline — all of its tests, not just the session in the URL (the server save is batch-scoped; the session part only identifies the batch). A potentially destructive, hard-to-reverse operation. Only call it once the user has explicitly approved committing the changes just made. | |
| eyes_resolve_reset | Restores every in-scope session's baseline to the revision the test originally ran against, and clears any pending (unsaved) accept/reject/region resolution back to unresolved. Unlike every other eyes_resolve_*/eyes_inspect_* tool, the URL's shape is not just a locator — it IS the scope: a session URL (even with a /steps/N suffix) resets only that one session, while a bare batch URL resets every session in the batch. If the user asks to reset "the batch"/"everything"/"all sessions" but only a session or step URL is on hand (e.g. reused from an earlier call in this conversation), strip it down to the bare batch form first — passing the session URL as-is will silently under-scope the reset. Destructive and not undoable — only call it with explicit user approval of that exact scope. | |
| eyes_review_progress | Tracks progress investigating whatever `scope` names — see its own description for what each one investigates and which arguments it takes. ALWAYS call this to initiate test results inspection at that level, and ALWAYS follow its `next` field for what to call next. Do not report findings or conclusions to the user before this review's own eyes_review_end call reports completion. In mode "resolve" this additionally acts on what it finds: dynamic content is masked with a match region as each diff is reported, and each step is accepted/rejected/left-unresolved deterministically from its own findings — the response's top-level `resolution` and `regions` tallies, plus each finding's own `regions` detail, report exactly what happened. | |
| eyes_review_end | Records the deduplicated findings summary for whatever `scope` names, once eyes_review_progress for that same scope reports every one of its children reviewed — see `scope`'s own description for what each one records, and `findings` for the shape each one takes. Discarded (not an error) if called too early. Always follow the returned `next` field — it tells you exactly what to do, whether that means retrying via eyes_review_progress, reviewing another entity at this same level, moving up to the level above, or the investigation is now fully reviewed. | |
| eyes_review_diff_report | Records the rich per-diff evidence for the changed areas of one step — one `reports` entry per area, every unreviewed area of the step in a single call, and every finding fully specified for its claimed category. Each entry is verified on its own, against its own areaRect: it hard-throws if eyes_inspect_evidence wasn't actually fetched for that areaRect, a finding claims dynamic.justification:"History" with no matching eyes_inspect_history call, a finding proposes a dynamic.mask fix with no eyes_inspect_regions call for this step, its mask's `before` doesn't match a region actually in effect right now, or its mask's `after` doesn't cover the finding's own area. Entries are processed in order and stop at the first rejection — the ones before it stay recorded, and the error names exactly which areas to send back. If an area is the exact same underlying change as an area already recorded in the same scenario, set its entry's `sameAs` instead of redoing the full trio — see its own description. In mode "resolve" each finding's `dynamic.mask` is turned into an actual checkpoint match-region change right here — `mask.after.area`, if left null/omitted, defaults to the finding's own `area` — and the response reports per finding what was added/adjusted (or why it could not be), on `regions` and appended to `description`. Always follow the returned `next` field — it tells you exactly what to do next, whether that's reporting more changed areas or moving up to the step level. |
구성
APPLITOOLS_API_KEYAPPLITOOLS_READ_KEYAPPLITOOLS_WRITE_KEY
| 이름 | 설명 | 유형 |
|---|---|---|
| APPLITOOLS_API_KEY | — | |
| APPLITOOLS_READ_KEY | — | |
| APPLITOOLS_WRITE_KEY | — |
자동 검사
2026년 11월 16일에 실행됨전체 보고서 →아직 인증되지 않았습니다. 서버는 80점 이상의 점수, 심각한 결함 없음, 그리고 검사에 충분한 데이터를 갖추어야 합니다. 검사 방식 · 점수를 높이기 위해 수정할 항목
- 소스 저장소 연결 및 접근 가능applitools/mcp is public and reachablegithub.com/applitools/mcp ↗통과
- 패키지가 이 저장소를 소스로 명시검사되지 않음
- 빌드 출처(Sigstore 증명)No build attestation published for this release검사되지 않음
- 오픈 소스 라이선스 (OSI)No license결함 발견
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-16github.com/applitools/mcp ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음No popular package one edit away from @applitools/mcp통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음the package checked; no critical advisoryosv.dev ↗통과
- 모델에 대한 숨겨진 지침 없음A tool description points at credential files결함 발견
- 파괴적인 도구에 라벨 표시됨No tool named like delete, drop or exec통과
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기Applitools MCP Server
The Applitools MCP server helps you create, update, review, and resolve visual tests using Applitools Eyes across any of our supported SDKs.
It connects to AI assistants through the Model Context Protocol (MCP), letting tools like Cursor, GitHub Copilot, Cline, and Claude Code (and more) set up tests, add visual checkpoints, configure cross-browser testing, and investigate visual test failures (accepting, rejecting, or adjusting the changes behind them) without ever leaving your IDE.
To learn more, please visit our MCP documentation.
Purpose
This server is built for developers, testers, or QA working with AI-assisted workflows.
It enables your AI assistant to:
- Understand your project configuration
- Guide Eyes setup
- Add visual checkpoints and suggest best practices
- Investigate a batch, scenario, session, or step of visual test failures and tell you what changed, whether it's a bug, and why
- Accept, reject, or adjust match regions for a checkpoint, with your explicit approval before anything is committed to baseline
All without requiring manual, error-prone steps, or leaving your IDE.
Who is this for?
- Engineers new to Applitools Eyes who haven't installed or implemented the Eyes SDK
- Existing Eyes SDK users who want to use the MCP server to add Ultrafast Grid coverage (cross-browser and device testing), convert existing tests into visual tests using Applitools visual AI, or retrieve and analyze visual test results
- Teams triaging visual test failures at scale
- Who want an AI assistant to investigate a batch of failing tests, gather evidence, and tell them exactly what changed and whether it needs attention, instead of clicking through the Eyes dashboard test by test
Requirements & Limitations
- Node.js 18 or newer
- VS Code, Cursor, Claude Code, Cline, or any other MCP client assistant
- The setup and checkpoint tools (eyes_setup_project, eyes_setup_ufg, eyes_add_checkpoints_to_test) support only our Playwright Fixtures SDK. Support for additional SDK frameworks is coming soon!
- Use the latest versions of Playwright, Node.js, and our Playwright JavaScript Fixtures SDK
- Requires access to your project's source code (for the setup and checkpoint tools)
- The Inspection, Resolution, and Review tools (
eyes_inspect_*, eyes_resolve_*, eyes_review_*) work with any Eyes test results, regardless of which SDK or language produced them, as they operate on already-captured batch, session, and DOM data- These tools require additional separate read and write API keys
Installation
Recommended: VS Code Extension or Cursor MCP Install
The easiest way to start using Eyes MCP is through the Applitools VS Code extension or by installing the MCP server directly in Cursor.
- Runs the MCP server automatically
- Connects it to Copilot or Cursor's AI assistant
- Provide context-aware code edits
- Surface visual test results inside your IDE or MCP client CLI of choice
Simply install the MCP server by clicking an option below:
Alternatively, you can install the server manually by following the Manual Setup section below.
Manual Setup
If you prefer not to use the extension, you can install the MCP server manually by following the examples below.
Standard MCP configuration:
{
"mcpServers": {
"applitools-mcp": {
"type": "stdio",
"command": "npx",
"args": ["--yes", "@applitools/mcp@latest"]
}
}
}
Please see the VS Code MCP install guide and use the standard config above.
Alternatively, install it via the VS Code CLI:
code --add-mcp '{"name":"applitools-mcp","command":"npx","args":["@applitools/mcp@latest"]}'
Create or edit the configuration file ~/.copilot/mcp-config.json and add:
{
"mcpServers": {
"applitools-mcp": {
"type": "local",
"command": "npx",
"tools": [
"*"
],
"args": [
"@applitools/mcp@latest"
]
}
}
}
Follow the instruction in the section Configuring MCP Servers
Add the following to your cline_mcp_settings.json file:
{
"mcpServers": {
"applitools-mcp": {
"command": "npx",
"args": ["--yes", "@applitools/mcp@latest"],
"disabled": false,
"type": "stdio",
"timeout": 60
}
}
}
claude mcp add applitools-mcp npx @applitools/mcp@latest
Follow the MCP install guide, and use the standard MCP configuration above.
Authentication
Three keys control what the server can do, set as global environment variables, in a .env file in your project, or update the applitools-mcp configuration in your mcp.json file:
- APPLITOOLS_API_KEY: Used for test execution (unchanged; this is the key you already use to run Eyes visual tests). See our documentation on retrieving your execution key.
- Note: The MCP server will look in additional places for this key. See the
eyes_verify_api_keytool for details.
- Note: The MCP server will look in additional places for this key. See the
- APPLITOOLS_READ_KEY: A read-only key. Required for all Inspection tools, for all Resolution tools, and for Review tools running in either mode.
- APPLITOOLS_WRITE_KEY: A write-only key. Required for all Resolution tools and for Review tools running in resolve mode (the default).
How to get read-only and write-only API keys:
See our documentation on API key management.
- Go to the Applitools Admin API Keys page.
- Create or copy a read-only API key associated with your user and team.
- Create or copy a write-only API key associated with your user and team.
- Set it via a
.envfile in your project, a global environment variable, or the applitools-mcp configuration in yourmcp.jsonfile.
Note: APPLITOOLS_API_KEY (for test execution) is different from APPLITOOLS_READ_KEY and APPLITOOLS_WRITE_KEY. The Inspection, Resolution, and Review tools (eyes_inspect_*, eyes_resolve_*, eyes_review_*) require these separate read-only and write-only permission keys to query session data, review/inspect, and resolve your tests.
Example applitools-mcp mcp.json configuration with all three keys set:
{
"mcpServers": {
"applitools-mcp": {
"type": "stdio",
"command": "npx",
"args": ["--yes", "@applitools/mcp@latest"],
"env": {
"APPLITOOLS_API_KEY": "<your execution API key>",
"APPLITOOLS_READ_KEY": "<your read-only key>",
"APPLITOOLS_WRITE_KEY": "<your write-only key>"
}
}
}
}
Example .env file in your project with all three keys set:
APPLITOOLS_API_KEY=<your execution API key>
APPLITOOLS_READ_KEY=<your read-only key>
APPLITOOLS_WRITE_KEY=<your write-only key>
Available Tools
Setup & Configuration
eyes_verify_api_key
Validates your Applitools API key and, if provided, verifies connectivity to a specified Eyes server URL (e.g., non-public cloud).
Searches common locations:
- APPLITOOLS_API_KEY environment variable and/or APPLITOOLS_SERVER_URL, if applicable
- .env file in your project
- applitools.config.*
- playwright.config.*
- applitools-mcp mcp.json configuration file
Supported Eyes SDKs: All
eyes_setup_project
Guides the setup of Applitools Eyes in your Playwright project (Fixtures variant).
Includes:
- The Eyes reporter configuration
- Extends the Playwright HTML report to include Eyes visual test results. Users can approve or reject results in the report without having to visit the Eyes dashboard.
- Adding Eyes settings and dependency imports into your project files
- Recommended defaults
Supported Eyes SDKs: Playwright TypeScript/JavaScript Fixtures
eyes_add_checkpoints_to_test
Adds Eyes visual checkpoints to your existing Playwright test in line with best practices.
Supported Eyes SDKs: Playwright TypeScript/JavaScript Fixtures
eyes_setup_ufg
Configures the Ultrafast Grid (UFG) for cross-browser and cross-device testing. Guides you through UFG setup to run visual tests across multiple browsers, viewports, and devices simultaneously.
Supported Eyes SDKs: Playwright TypeScript/JavaScript Fixtures
Inspection (read-only)
Requires APPLITOOLS_READ_KEY. These tools query batch, session, step, and DOM data without changing anything. Your assistant typically calls these on your behalf as part of a Review (see below); you can also ask for any of them directly for manual or ad-hoc investigation.
Supported Eyes SDKs: All
eyes_inspect_sessions
Lists a batch's sessions and batch-wide stats. Narrow to only unresolved or unsaved sessions, or shape the response to full detail, stats only, or a deduplicated list of scenario names. The entry point for browsing a batch. Use this first when asking "what's in this batch?" or "what still needs review?"
eyes_inspect_steps
Lists a session's steps: whether each is matching, plus baseline/checkpoint image and DOM IDs, sizes, and resolution status. Use when drilling into one session.
eyes_inspect_changed_areas
Returns a step's diff regions, clustered from raw pixel-level differences and already accounting for any regions you've added. Past 20 changed areas in a step, dense clusters are grouped into a single enclosing area, so your assistant focuses on what's meaningfully different rather than pixel noise.
eyes_inspect_image
Exports a baseline or checkpoint screenshot for a step, optionally cropped to a specific area.
eyes_inspect_image_diff
Exports the checkpoint screenshot with changed areas highlighted, so you can see at a glance what moved or changed.
eyes_inspect_dom
Exports a DOM capture for a step to a file, with a stable id assigned to every element so your assistant can reference "element 14" instead of an XPath or raw coordinates. Requires DOM capture to have been enabled when the test ran; returns no data (not an error) otherwise.
eyes_inspect_dom_diff
Returns the structural difference between a step's checkpoint and baseline DOM (only what actually changed), with pure position shifts and mass changes (e.g. "everything below moved down") automatically consolidated instead of listed element by element.
eyes_inspect_dom_search
Searches a DOM capture using a predicate query language, documented as its own MCP resource: combine property comparisons, geometry and size checks, ancestor/descendant relationships, and shortcut keywords like image or button with and/or/not, instead of requiring your assistant to read the entire capture.
eyes_inspect_evidence
Returns everything needed to review a step's changed areas in one call: for each area you ask about, the image diff plus the baseline and checkpoint screenshots, together with the step's whole DOM diff and the match regions currently in effect. Preferred over calling eyes_inspect_image_diff, eyes_inspect_image, eyes_inspect_dom_diff and eyes_inspect_regions separately; it is what a Review gathers its evidence with.
eyes_inspect_regions
Returns the match regions currently in effect for a step, combining regions defined in your test code with any added or changed since the test ran. Checked before adding a new region, so your assistant doesn't create an overlapping or duplicate one.
eyes_inspect_history
Returns a DOM node's diff history across prior runs, used as evidence that a change is recurring/dynamic content rather than a one-time real change.
Review (orchestration)
Requires APPLITOOLS_READ_KEY always, and additionally APPLITOOLS_WRITE_KEY when running in resolve mode (the default). This is the primary way to use these tools day-to-day: ask your assistant to review a batch, scenario, session, or step, and it drives the full investigation for you.
Supported Eyes SDKs: All
eyes_review_progress
Drives a guided investigation at whatever scope you ask for (a batch, a scenario, a session, or a single step), gathering the evidence (images, DOM diff, history) needed for each changed area before a finding can be reported. This is the tool your assistant reaches for when you say "review my batch" or "review this session"; it calls the Inspection tools internally in the right order, so you don't have to.
eyes_review_diff_report
Records a structured finding for one changed area: its classification, whether it's consistent with the surrounding page, bug status, expected status, and (if it's recurring/dynamic content) supporting evidence and a recommended mask. Requires your assistant to gather the relevant evidence first; a finding filed without it is rejected and redirected back to whichever inspection call is missing.
eyes_review_end
Summarizes and finalizes the investigation at the given scope, deduplicating every child finding into one clean summary with nothing dropped or double-counted. At the step level, this is also where a step's accept/reject/unresolved outcome is decided (in resolve mode).
Two Review modes:
- inspect: read-only. Produces a summary of what changed with no mutation. Good for a first look, or when you want to see findings before deciding what to do.
- resolve (the default): additionally applies masks for confirmed-dynamic diffs and decides each step's accept/reject/unresolved outcome automatically, as findings come in. Your assistant never has to call the Resolution tools independently to make this happen.
Either mode can be scoped to a whole batch or narrowed to a single scenario, session, or step. A completed inspect-mode review can later be promoted to resolve mode without redoing the investigation; its cached findings are simply replayed through the resolve-mode decision logic. Saving changes to the baseline, or resetting it, is never part of Review itself; ask separately for eyes_resolve_save (or eyes_resolve_reset), each of which still requires your explicit approval.
Resolution (mutating)
Requires both APPLITOOLS_READ_KEY and APPLITOOLS_WRITE_KEY. In ordinary use, you generally won't call these directly. Review applies the equivalent decisions automatically as it works through a batch. Reach for these tools directly only for one-off, manual resolution outside of a Review, e.g. accepting a single already-understood step without running a full investigation.
Supported Eyes SDKs: All
eyes_resolve_checkpoint
Marks a step's checkpoint as accepted or rejected. Accepted checkpoints replace the baseline once saved; rejected ones keep the existing baseline. By default, applies the same decision to every step sharing the identical diff, both within the session and across sibling sessions with the same scenario name.
eyes_resolve_regions
Adds, removes, or updates a step's match regions, read against either the baseline or the checkpoint image/DOM. Propagates the same way as eyes_resolve_checkpoint.
Note: This tool always requires your explicit approval before running
eyes_resolve_save
Commits every accepted/rejected step and every region change in the whole batch to the baseline — all of the batch's tests, not just the session you name. Until this runs, resolution decisions stay pending and the baseline is untouched.
Note: This tool always requires your explicit approval before running
eyes_resolve_reset
Restores a session's or batch's baseline to the revision the test originally ran against, and clears any pending resolution decisions.
Note: This tool always requires your explicit approval before running
Getting started & Usage Examples
Ask your AI assistant about Applitools:
- "Using the Applitools MCP server, perform the following tasks"
- This prompt prefix is optional and can guide your assistant to use the MCP server for better results.
- "Verify my Applitools API key"
- "Set up Applitools Eyes for my Playwright project"
- For Playwright TypeScript/JavaScript
- "Add Eyes visual checkpoints to my login.spec test"
- For Playwright TypeScript/JavaScript
- "Configure cross-browser testing with the Applitools UFG"
- For Playwright TypeScript/JavaScript
- "Show me the batch URL for my last test results"
- "Analyze and summarize my batch results"
- "Review my last batch and tell me what changed"
- "Just show me what changed in this batch, don't resolve anything yet"
- "That all looks right. Go ahead and resolve it now"
- "Accept the checkout button diffs across all sessions in this scenario"
- "Is this diff on the timestamp element dynamic, or a real change?"
- "Reset this batch's baseline to what it originally ran against"
Helpful links
Built with ❤️ by Applitools
Applitools MCP 질문
Applitools MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add mcp -- npx -y @applitools/mcp를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
Applitools MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
Applitools MCP는 어떤 도구를 제공하나요?
22개 도구를 제공합니다. 예: eyes_verify_api_key, eyes_setup_project, eyes_setup_ufg, eyes_add_checkpoints_to_test, eyes_inspect_sessions.
프로젝트 설정 및 체크포인트 추가를 위해 어떤 SDK를 지원하나요?
현재 설정 및 체크포인트 도구는 Playwright Fixtures SDK만 지원합니다.