Applitools MCP sunucusu
Commit 12 Kas 2026Yapay zeka asistanlarının, IDE'niz içerisinden ayrılmadan Applitools Eyes kullanarak görsel testler oluşturmasına, güncellemesine, incelemesine ve çözmesine olanak tanır.
Ayrıca bilinen adı applitools/mcp, mcp, @applitools/mcp
- Yıldızlar
- 0
- Araçlar
- 22
- İndirmeler, 30 gün
- 4.951
- En son sürüm
- 1.0.17
- Son commit
- 12 Kas 2026
- Lisans
- —
Applitools MCP nedir?
Yapay zeka asistanlarının, IDE'niz içerisinden ayrılmadan Applitools Eyes kullanarak görsel testler oluşturmasına, güncellemesine, incelemesine ve çözmesine olanak tanır. 22 araç sunar; örneğin eyes_verify_api_key, eyes_setup_project, eyes_setup_ufg.
Özet, projenin README dosyasından oluşturuldu
Applitools MCP sunucusu hakkında
Bu sunucu, geliştiricilerin ve QA mühendislerinin görsel regresyon testlerini bir yapay zeka asistanı aracılığıyla yönetmesini sağlar. Cursor, Claude Code veya GitHub Copilot gibi istemcilere bağlanarak, IDE'nizden ayrılmadan Applitools Eyes kullanarak görsel testler oluşturmanıza, güncellemenize ve çözmenize imkan tanır. Özellikle Eyes SDK'sını ilk kez kuran mühendisler veya başarısız olan çok sayıda testi hızlıca sınıflandırması gereken ekipler için oldukça kullanışlıdır.
Kurulum ve checkpoint araçları şu anda Playwright Fixtures SDK'sını desteklerken; inceleme ve çözüm araçları, kullanılan dilden bağımsız olarak tüm Eyes test sonuçlarıyla çalışabilir. Bu özellikleri kullanmak için bir execution API key ile birlikte, test verilerini incelemek ve çözmek için ayrı okuma ve yazma anahtarları sağlamanız gerekir. Sunucu, Node.js aracılığıyla yerel olarak çalışır ve bir VS Code eklentisiyle veya MCP istemci ayarlarınızdaki manuel yapılandırma ile kurulabilir.
Neler yapabilirsiniz
- 1Playwright görsel test kurulumunu otomatize edinYapay zeka asistanınızdan Eyes reporter'ı yapılandırmasını ve mevcut Playwright testlerinize görsel checkpoint'ler eklemesini isteyin.
- 2Tarayıcılar arası test yapılandırması yapınBirden fazla tarayıcı ve cihazda eş zamanlı test yapabilmek için asistanın Ultrafast Grid kurulumunu gerçekleştirmesini sağlayın.
- 3Görsel test hatalarını inceleyinNeyin değiştiğini ve bunun bir hata olup olmadığını tam olarak belirlemek için başarısız olan test gruplarının analiz edilmesini talep edin.
- 4Görsel tutarsızlıkları çözünBir checkpoint için eşleşme bölgelerini (match regions) onayınızla kabul etmek, reddetmek veya ayarlamak için asistanı kullanın.
Projenin README dosyasından alınmıştır. Her kullanım durumu, oradaki bir alıntı ile kontrol edilir.
Applitools MCP nasıl yüklenir
Biçimler 10 Kas 2026 tarihinde doğrulandıCursor'a ekleGoose'a ekleApplitools MCP'yi Claude Code içine yükleyin
$ claude mcp add mcp -- npx -y @applitools/mcpApplitools MCP'yi Cursor içine yükleyin
~/.cursor/mcp.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}Applitools MCP'yi VS Code içine yükleyin
.vscode/mcp.json
{
"servers": {
"mcp": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}Applitools MCP'yi VS Code CLI içine yükleyin
$ code --add-mcp '{"name":"mcp","type":"stdio","command":"npx","args":["-y","@applitools/mcp"]}'Applitools MCP'yi Claude Desktop içine yükleyin
claude_desktop_config.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}Applitools MCP'yi Codex içine yükleyin
$ codex mcp add mcp -- npx -y @applitools/mcpApplitools MCP'yi Codex config.toml içine yükleyin
~/.codex/config.toml
[mcp_servers.mcp] command = "npx" args = ["-y", "@applitools/mcp"]
Applitools MCP'yi Gemini CLI içine yükleyin
$ gemini mcp add -s user mcp npx -- -y @applitools/mcpApplitools MCP'yi Gemini settings.json içine yükleyin
~/.gemini/settings.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@applitools/mcp"
]
}
}
}HostedMCP tarafından 16 Kas 2026 tarihinde başlatıldı
Bu komutu @applitools/mcp 0.10.5 için ağsız ve anahtarsız, yalıtılmış bir konteynerde çalıştırdık. Yanıt verdi ve 22 araç listeledi.
Applitools MCP araçları 22
Sunucudan tools/list ile okundueyes_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_sessionsSalt okunurList 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_stepsSalt okunurSession 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_areasSalt okunurCoarse 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_diffSalt okunurExport 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_imageSalt okunurExport 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_evidenceSalt okunurEverything 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_domSalt okunurExport 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_searchSalt okunurSearch 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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). | Salt okunur |
22 aracın tümünü gösterDaha az araç göster
eyes_inspect_dom_diffSalt okunurStructural 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_regionsSalt okunurThe 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_historySalt okunurFor 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. | Salt okunur |
| 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. | Salt okunur |
| 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. | Salt okunur |
| 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. |
Yapılandırma
APPLITOOLS_API_KEYAPPLITOOLS_READ_KEYAPPLITOOLS_WRITE_KEY
| Ad | Açıklama | Sunucu |
|---|---|---|
| APPLITOOLS_API_KEY | — | |
| APPLITOOLS_READ_KEY | — | |
| APPLITOOLS_WRITE_KEY | — |
Otomatik kontroller
Çalıştırıldı 16 Kas 2026Tam rapor →Henüz doğrulanmadı. Bir sunucunun 80 puana, ciddi bir bulgu olmamasına ve kontrol edebilmemiz için yeterli veriye ihtiyacı vardır. Kontroller nasıl çalışır · Daha fazla puan için nelerin düzeltileceği
- Kaynak deposu bağlantılı ve erişilebilirapplitools/mcp is public and reachablegithub.com/applitools/mcp ↗Geçti
- Paket, bu depoyu kaynağı olarak gösteriyorKontrol edilmedi
- Derleme kökeni (Sigstore onayı)No build attestation published for this releaseKontrol edilmedi
- Açık kaynak lisansı (OSI)No licenseBulgu
- Son bir yıl içinde commit veya sürüm mevcutLast commit or release 2026-11-16github.com/applitools/mcp ↗Geçti
- OpenSSF ScorecardKontrol edilmedi
- Paket adı popüler bir pakete yakın değilNo popular package one edit away from @applitools/mcpGeçti
- Pakette veya bağımlılıklarında kritik uyarı yokthe package checked; no critical advisoryosv.dev ↗Geçti
- Modele yönelik gizli talimat yokA tool description points at credential filesBulgu
- Yıkıcı araçlar etiketlenmişNo tool named like delete, drop or execGeçti
- Uzak uç nokta MCP el sıkışmasına yanıt veriyorKontrol edilmedi
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 soruları
Applitools MCP'yi Claude Code'a nasıl eklerim?
Terminalinizde claude mcp add mcp -- npx -y @applitools/mcp komutunu çalıştırın. Her projede kullanılabilir olması için --scope user ekleyin.
Applitools MCP'yi Cursor'a nasıl eklerim?
~/.cursor/mcp.json dosyasını açın ve yukarıdaki yükleme bölümünde gösterilen Cursor yapılandırmasını kullanarak sunucuyu mcpServers altına ekleyin.
Applitools MCP hangi araçları sunar?
22 araç sunar; bunlar arasında eyes_verify_api_key, eyes_setup_project, eyes_setup_ufg, eyes_add_checkpoints_to_test, eyes_inspect_sessions yer alır.
Proje kurulumu ve checkpoint ekleme için hangi SDK'lar destekleniyor?
Şu anda kurulum ve checkpoint araçları yalnızca Playwright Fixtures SDK'sını desteklemektedir.