MCP Tools Reference
Detailed schema specifications for every Wevi Model Context Protocol tool.
Wevi MCP Tools Reference
The @wevi/mcp package exposes 39 Model Context Protocol tools. The happy path is list templates → read schema → create one project with all scenes → trigger render → poll status. Every scene of a video lives in one project and is exported as one concatenated MP4.
wevi_list_templates— pick published templates from one aspect ratio.wevi_get_template_schema— read each template's editable layer keys.wevi_create_project— one project withscenes: [...].wevi_trigger_render— render every scene and export one MP4.wevi_get_render_status— poll untilphaseiscompleted, then usevideoUrl.
1. wevi_list_templates
List published templates. Only published templates can be used in projects; drafts and archived templates are never returned to API keys.
| Field | Type | Required | Description |
|---|---|---|---|
category | string | No | Filter by category (SaaS, CTA, Problem, Solution, Motion, …) |
aspectRatio | "16:9" | "16:12" | "9:16" | No | 16:9 = 1920×1080 widescreen, 16:12 = 1920×1440 desktop-app frame, 9:16 = 1080×1920 vertical (the templates that have a vertical version) |
search | string | No | Keyword matched against names, slugs and descriptions |
limit | number | No | 1–100 (default 100: the whole library, in story order) |
page | number | No | Page number |
Each result carries aspectRatio (the template's own frame), aspectRatios (every ratio a video using it can be made in; 9:16 when it has a vertical version), storyboardRole (the beat it plays best: hook, problem, solution, proof, cta or transition), fitsBeats (every beat it can play), purpose, avoid, tone, voiceoverBudget (max words and characters for the scene length), requiresUiCapture, uiCaptureSlots, and for capture templates fitsUi and alsoSuitsUi (the kinds of interface they show best: match them against productUi from wevi_open_page). A paged result says incomplete. Pick all templates for one video from a single aspect ratio. Templates with requiresUiCapture: true show real product UI: capture a page into those scenes with wevi_capture_scene after creating the project. Capture slots you leave unfilled render empty (no stock or demo imagery), so capturing fewer components than uiCaptureSlots.max is safe.
2. wevi_get_template_schema
Returns the editable layers of a template: key, label, type (text, color, slider, toggle, dropdown, image, …), role (logo, external_logo, avatar, background, brand_name, ui_component), autoFill (what Wevi fills the layer with when you leave it unset), description, default value, validation (min/max) and dropdown options. Hidden and protected layers are omitted. brandLogoLayers lists the keys that need a brand logo. The result also carries previewVideoUrl and thumbnailUrl, and the tool attaches the thumbnail as an image so you can judge the look of the animation before committing to it.
| Field | Type | Required | Description |
|---|---|---|---|
templateId | string | Yes | Template ID or slug |
3. wevi_create_project
Create one project containing all scenes of the video. The aspect ratio is derived from the templates; mixing ratios is rejected. Pass aspectRatio: "9:16" for a vertical video: every template must have a vertical version.
| Field | Type | Required | Description |
|---|---|---|---|
title | string | No | Project title |
aspectRatio | "16:9" | "16:12" | "9:16" | No | Leave out to use the templates' own frame; 9:16 renders each scene from its template's vertical version |
scenes | Scene[] | Yes | 1–12 ordered scenes |
brandId | uuid | No | Existing brand to attach (skip when passing brand) |
brand | Brand | No | Brand for logo and color layers; required (websiteUrl or logoUrl) when any template has a logo slot |
Brand:
| Field | Type | Required | Description |
|---|---|---|---|
websiteUrl | string | No | Product website or domain, e.g. stripe.com. Wevi fetches the logo, colors and fonts and reuses the brand on later projects |
logoUrl | url | No | Public logo image (png, svg, jpg, webp) when there is no website, or to override its logo |
name | string | No | Brand or product name |
primaryColor, secondaryColor | string | No | Brand colors (hex) |
Scene:
| Field | Type | Required | Description |
|---|---|---|---|
templateId | string | Yes | Published template ID or slug |
parameters | object | No | Layer key → value ({"TXTTYPINGVAR": "Hello"}) |
voiceoverText | string | No | Narration mixed in at export |
title | string | No | Scene title |
Returns projectId, aspectRatio, sandbox, the resolved brand and the created scenes, each with autoFilled (layer keys Wevi filled from the brand: logo, app logos, avatars, backgrounds, colors) and templateCopy (layers still showing the template's own words). It also returns scenesNeedingCapture (capture each with wevi_capture_scene before rendering), planReview (fix every entry in planReview.issues before rendering), and credits, with a creditWarning when the balance cannot pay for the whole video. If a template has a logo slot and the brand has no logo, the call is refused with missingBrandAssets; ask the user for the product website and retry.
3c. wevi_update_scene
Change one scene after creation, typically to fix a failed render without rebuilding. The next wevi_trigger_render re-renders only scenes whose inputs changed, and charges for those scenes.
| Field | Type | Required | Description |
|---|---|---|---|
projectId | string | Yes | Project ID |
sceneId | string | Yes | Scene ID |
parameters | object | No | Layer key → value, merged over current values; null clears |
voiceoverText | string | No | New narration within the scene's budget |
title | string | No | New scene title |
3d. Revising a project
Change a project without rebuilding it. The next wevi_trigger_render re-renders only scenes whose inputs changed.
| Tool | Fields | Notes |
|---|---|---|
wevi_add_scene | projectId, templateId, position?, title?, voiceoverText?, parameters? | Same aspect ratio as the project; unset layers auto-fill; capture templates then need wevi_capture_scene |
wevi_remove_scene | projectId, sceneId | Remaining scenes close the gap |
wevi_reorder_scenes | projectId, sceneIds[] | Every scene id exactly once, in the new order |
wevi_swap_template | projectId, sceneId, templateId, parameters? | Matching parameters carry over; dropped keys are listed |
Text layers you leave unset on create, add or swap are filled from the scene title, else the start of the narration, else the project title. Layers that still show the template's own words are listed per scene as templateCopy; set them with wevi_update_scene when the copy matters. A required text layer with nothing to draw from is refused with missingText.
4. wevi_get_project
Inspect a project's scenes, layer values and lifecycle status. The response also lists pendingCaptures (scenes that still need wevi_capture_scene) and a nextStep.
| Field | Type | Required | Description |
|---|---|---|---|
projectId | string | Yes | Project ID |
5. wevi_trigger_render
Render every scene, then export them as one video with music and voiceover. Waits up to waitSeconds; if the video is not ready it returns the current phase for polling.
| Field | Type | Required | Description |
|---|---|---|---|
projectId | string | Yes | Project ID |
quality | "720p" | "1080p" | "4K" | Yes | When paidAccess is true (any credit pack bought, or a paid plan), ask the user once before the first render: 1080p for web and social, 4K (slower to export, and it costs more) for large screens. Otherwise pass 720p: a free account asking for 1080p or 4K gets 403 EXPORT_QUALITY_LOCKED. Sandbox keys are capped at 720p without an error |
includeMusic | boolean | No | Default true. Projects with no track yet get one from the Wevi library automatically; the response's music says which |
musicTrackId | string | No | Library track id to use instead of the automatic pick. Needs paid access (403 FEATURE_NOT_AVAILABLE otherwise) |
voiceId | string | No | Narrator from wevi_list_voices instead of the default. Needs paid access (403 FEATURE_NOT_AVAILABLE otherwise) |
includeVoiceover | boolean | No | Default true. Narration is generated from each scene's voiceoverText |
soundEffects | "off" | "subtle" | "full" | No | Sound design planned by Wevi (see Sound effects). subtle is quieter and sparser and suits most product videos; full is a launch-trailer feel; off suits a calm or personal piece. Saved on the project; omitted, the project's setting stands (off unless set). No extra credits |
soundStyle | "clean" | "cinematic" | "playful" | "tech" | No | Character of the cuts' and accents' sounds, matched to the music: clean (the default), cinematic for a dramatic launch, playful for a light consumer product, tech for developer tools and AI products. Saved on the project |
waitSeconds | number | No | 0–55 (default 45) |
Calling wevi_trigger_render again after a failed export, with the same options, starts that same export again: it is not charged twice, and scenes already rendered are not rendered again.
5b. wevi_get_scene_previews
Per-scene render results: state, a preview URL for each rendered scene (the scene alone, without music), and the error for failed ones. Scenes that failed before reaching the renderer say "Credit refunded". Takes projectId.
5c. wevi_list_music and wevi_list_voices
Library tracks with mood and genre tags (wevi_list_music takes an optional query), and narrator voices with preview clips. Pass musicTrackId or voiceId to wevi_trigger_render; without them Wevi picks a track for the brand's tone and the default narrator.
5d. Sound effects
Wevi plans a video's sound effects itself, for its scenes and its narration, by the rules a sound designer keeps:
- A sound only on a moment the eye follows: a cut, a title or logo landing, a click, a message popping in, an element flying in. Nothing where nothing happens.
- The right sound for what happens. Every template's moments were timed on its preview, and each was given the library sound that matches it: Payment done when a payment is confirmed, Message pop when a chat message appears, Enter key when a command is submitted, Stamp when a badge is stamped on.
- Not every cut. A cut gets a whoosh when the story moves on (problem to solution, into proof) or the picture moves fast across it. A cut where the same thought carries on, where the voice runs across it, or between two calm frames stays bare. Cuts between short scenes never whoosh one after another.
- Accents on the full treatment: a hit on the opening title, a soft hit on the logo, with quiet just before it.
- The voice comes first. Sounds landing on a spoken word sit lower; a light touch leaves the movements out. Everything ducks under the voice in the mix.
- One palette. The same action sounds the same through the video, and the cuts take turns between two whooshes of the style.
- Never busy. At most three sounds in any second (two on a light touch), a few to a scene, levels matched for how loud each sound actually is.
Templates that carry their own sound keep it and get none of Wevi's. The plan stands on its own; the tools below read it and change single sounds when there is a reason. Each returns the sound design as it now plays, with advice: what a sound designer would fix (empty when the sound is right).
| Tool | What it does | Fields |
|---|---|---|
wevi_get_sound_design | Every sound with its key, scene, moment (atSeconds into the scene), what happens there, the library sound, its levelDb against the plan; the sounds taken out; the scenes; the library; the advice. Read-only | projectId |
wevi_set_sound_effects | Sets the level, style and volume | projectId, level, style, volume (0–100) |
wevi_change_sound | Another library sound, a level against the plan (levelDb: 0 as planned, -3 a clear step quieter), a moment (nudgeSeconds, within 2 seconds), and for typing, ticks or scrolling how long it runs (lengthSeconds; the sound repeats to fill it). Values are set, not stepped | projectId, key, sound, levelDb, nudgeSeconds, lengthSeconds |
wevi_add_sound | A library sound at a moment of a scene | projectId, sceneId, atSeconds, sound, levelDb, lengthSeconds |
wevi_remove_sounds | Takes sounds out; they stay under removed | projectId, keys |
wevi_restore_sounds | Puts sounds back, or with all undoes every change to single sounds | projectId, keys, all |
6. wevi_get_render_status
Poll render + export progress. Returns phase (idle, rendering, exporting, completed, render_failed, failed) and videoUrl once completed, with music and voice. Polling is also what starts the export once every scene has rendered. review, when present, is Wevi's check of the finished video: share videoUrl once review.status is done with no issues; otherwise fix the scenes it names (each issue has a suggestedFix) with wevi_update_scene and render again. beforeSharing says what to check with the user first.
| Field | Type | Required | Description |
|---|---|---|---|
projectId | string | Preferred | Project started with wevi_trigger_render |
exportId | string | Alt | Look up a single export record |
waitSeconds | number | No | 0–55 |
While exporting, export.stall says when the export is not moving: paused when it has waited a few minutes with nothing putting videos together yet (it starts as soon as exports resume), quiet when it stopped making progress again after being started again. An export that stops making progress is started again once on its own (export.restarted: true), as the same export and without charging again. nextStep says what to do in each case.
7. wevi_generate_storyboard
Plan a storyboard from a brief against the published templates. The plan already follows the create rules, so its createPayload can go straight to wevi_create_project: every scene uses a published template from one aspect ratio, each scene's narration sits inside that template's voiceover budget as a complete sentence, on-screen copy is written for the template's text layers, and scenes that show real product UI are flagged so you know what to capture. Charged as a storyboard draft on live keys (see costs in wevi_get_credits) and takes 20–60 seconds (progress is reported while it runs).
| Field | Type | Required | Description |
|---|---|---|---|
prompt | string | Yes | Goal, product, audience and tone |
brandName | string | No | Brand or product name |
brandUrl | string | No | Product website or domain; becomes createPayload.brand.websiteUrl so create can fetch the logo and colors |
brandVoice | string | No | Tone of voice |
brandId | string | No | A saved brand from wevi_list_brands (wins over brandName / brandUrl) |
maxScenes | number | No | Exact scene count, 3–12. Omit to let the brief and runtime decide (3–6 scenes) |
targetDurationSeconds | number | No | 10–180; scene count and pacing follow it, so longer videos get more scenes |
aspectRatio | "16:9" | "16:12" | "9:16" | No | Aspect ratio for every scene (default 16:9); 9:16 plans a vertical video from the templates with a vertical version |
captureUi | boolean | No | true when the user has a live product page to capture (prefers UI templates); false avoids capture templates |
sessionId | string | No | A session open on the product (from wevi_open_page): templates are matched to the interface its pages show (productUi) |
Returns credits, planReview, productUi, draft (title, narrativeAngle, aspectRatio, totalDurationSeconds and scenes), createPayload, notes and nextStep. Each scene lists order, title, purpose, visualDirection, templateId, templateName, storyboardRole, durationSeconds, voiceover, voiceoverBudget (seconds, maxChars, maxWords), onScreenText, parameters (layer key → copy), textSource (ai, onScreenText or none), textLayerKeys (the template's text layers; empty when it has none), requiresUiCapture, captureSlots and captureHint. Show the plan to the user, adjust wording if asked (stay within voiceoverBudget.maxChars), then send createPayload to wevi_create_project; when the draft had no website, ask for it and add it as createPayload.brand.websiteUrl first. Sandbox keys are limited to 4 scenes per project, and drafts made with them respect that.
8. Browsing before you capture
Use these when the right shot is not the top of a public page: a tab, a modal, a dashboard behind a login the user walks you through, or a section further down.
Limits: 12 session opens per minute, 60 browse or outline calls per minute, 3 open agent sessions at a time, and a daily browser-time allowance (120 minutes on live keys, 40 on sandbox keys); past a limit the tool returns a 429 that says when it resets. A session stays on the site it was opened for, plus any site you open on purpose with a goto step: a step that lands on another site is undone and reported as refused.
wevi_open_page
Open a live browser session and get the page outline: headings, links, sections with their vertical positions, scroll state and a small screenshot of the view it opens on. Wevi also looks down the rest of the page for you: an overview image shows its further views, numbered by their place down the page (1 is the top), and productUi counts the interface found further down, labelled as such.
| Field | Type | Required | Description |
|---|---|---|---|
url | string | Yes | Page to open |
projectId, sceneId | string | No | Sets the viewport to that scene's template |
On a marketing site, the result may also carry appEntry and appHint: where the product itself is (often behind a sign-in), since the product's own screens usually make better scenes than its marketing pages.
Browsing in the session
One tool per step, each taking sessionId (from wevi_open_page) and an optional screenshot (default true), and each returning the resulting outline and screenshot. Steps that look like payments, purchases, deletions or account changes are refused; at most 150 steps per session; only http(s) pages, on the site the session was opened for or reached with wevi_go_to.
| Tool | Fields | What it does |
|---|---|---|
wevi_go_to | url | Opens another page of the site, or one of the app's routes; like wevi_open_page, returns an overview of the rest of that page |
wevi_click | selector or text, opensMenu? | Clicks an element; opensMenu: true clicks, of the controls whose text matches, one that opens a menu or list first |
wevi_type | selector, text, submit?, clear? | Types into a field; never a password |
wevi_hover | selector | Shows what appears on hover |
wevi_scroll | selector or y or ratio | Scrolls to an element, a pixel position, or a share of the page (0–1) |
wevi_wait | ms or selector | Waits for a time (at most 10 s) or for an element to appear |
wevi_press_key | key | Presses a key, e.g. Escape or Enter |
wevi_go_back | Goes back one page; returns an overview like wevi_go_to | |
wevi_wait_for_login | timeoutSeconds? (15–300, default 180) | Call right after sending the user loginUrl: waits until they press I am signed in or the sign-in screen goes away, then returns signedIn and the app's routes |
wevi_close_page
Close the session. Agent sessions also close after 10 minutes idle, when the project is published, or after 55 minutes. Browser time is metered: the first minutes of each session are free, then each started block is charged, shown as "Browser session" in the usage panel; sandbox keys are free. Each capture is charged as a page capture. The current free minutes, block length and costs are in wevi_get_credits.
wevi_capture_from_image
Use a still image at a public URL as the captured page. Works for templates whose whole background is the page (uiCaptureSlots.fullPageBackground); templates that animate individual elements need the live page. Free.
| Field | Type | Required | Description |
|---|---|---|---|
projectId, sceneId | string | Yes | Scene to fill |
imageUrl | url | Yes | png, jpg or webp, up to 15 MB; fitted to the frame |
page | number | No | For templates that show several pages (uiCaptureSlots.pages): which page this image fills, from 1. Left out, the next page not yet captured |
8a. wevi_capture_scene
Capture a live web page into a scene whose template needs a UI capture. Loads the URL, detects UI components the same way the Wevi app does, auto-selects the best ones, and makes the scene render-ready. Charged as a page capture on live keys.
On a page nobody scrolled, Wevi looks down the whole page, view by view, and captures the view whose components suit the scene best; the result's lookedDown says where: the stops looked at (scanned), the views measured (views), the view taken (top, moved), each view's rank (scores) and, with annotate, the quick look stop by stop (looked). A view you scrolled to in the session is kept as it is, and selectors are brought into view wherever they sit on the page.
| Field | Type | Required | Description |
|---|---|---|---|
projectId | string | Yes | Project ID |
sceneId | string | Yes | Scene ID, from scenesNeedingCapture in the create response |
url | string | No* | Product page to capture. *Required unless sessionId is given |
focus | string[] | No | Up to 6 keywords matched against component labels and text, and against the words of each part of the page when Wevi looks down it, e.g. ["pricing table"] |
selectors | string[] | No | Up to 6 exact CSS selectors to use, in order; overrides auto-selection |
autoSelect | boolean | No | false captures and lists candidates without choosing (with a numbered screenshot), for an agent-driven pick |
sessionId | string | No | Open session from wevi_open_page; captures its current view (url optional) |
frame | "auto" | "current" | "full" | No | auto (default) narrows the viewport and scrolls so the chosen components fill about 60% of the frame; current keeps the view as browsed; full is the top of the page |
targetFill | number | No | 0.3–0.95, default 0.6 |
keepSession | boolean | No | Keep the session open (returns sessionId) to capture more scenes from the same site |
annotate | boolean | No | Also return a screenshot with numbered candidate boxes |
page | number | No | For templates that show several pages (uiCaptureSlots.pages): which page of the template this capture fills, from 1. Left out, the next page not yet captured. The result's pages says which are captured and which are missing; a page left empty repeats the captured ones |
A page whose title or headings say it does not exist ("404", "This page could not be found") is captured if you ask, but the result carries notFound: true and a warning: check the address and capture the page you meant before rendering. Every page outline also carries notFound.
Returns the chosen components, the candidates list ranked best-first (label, type, size, selector, number, suggested), the template's slots (min/max picks or full-page background, plus the template's selection rubric: guide, smartGuide with the author's do and don't notes, prefer, avoid, size, targetFill, and, for templates whose frames have been measured, frameShape (min–max width over height a frame shows whole) and frameSize (width, height and crops: how large a frame shows a component, in the page's own pixels)), captureNotes explaining how captures work, elapsedMs, and renderReady. Candidates are ranked by your focus hints first, then by fit: page content over navigation, headers and footers; cards, buttons and inputs over loose text; readable sizes over slivers and whole sections. A capture opens the page in a real browser, closes cookie and consent notices (choosing "reject" or "necessary only" when offered, otherwise "accept" or the close control) after every navigation, hides sticky bars and chat widgets, recaptures the background with the chosen components hidden, and usually takes 40 to 70 seconds; the tool reports progress while it runs. The page is measured first without a screenshot, framed once if the picks need it, then captured once over a single browser connection, so auto framing no longer costs a second capture. timingsMs in the result shows where the time went (openSession, steps, probe, frame, capture, finalize). frame in the result says which viewport and scroll position were used. If the choice is wrong, re-pick without reloading:
8b. wevi_select_capture
Choose different components from an existing capture. Takes projectId, sceneId, captureId, and selectedComponentIds (for text templates the first id must be the text element); optional keepSession, and cursorPoints for cursor templates (up to 12 { x, y } stops in the capture's pixels, in order; omitted, the stops are spread over the selected components). Free.
8c. wevi_capture_web_ui
Standalone screenshot of a URL, returned as an image URL for templates with a plain image slot (logo, avatar, background).
| Field | Type | Required | Description |
|---|---|---|---|
url | string | Yes | Public or app URL (e.g. https://linear.app) |
selector | string | No | CSS selector to crop one element |
viewport | string | No | desktop (1280×720, default) or mobile (390×844) |
Returns screenshotUrl and title. Charged as a page capture on live keys.
0. wevi_get_capabilities
Returns what Wevi can and cannot make, the questions an agent should ask before building, the supported aspect ratios, sandbox limits, and credit costs. Takes no parameters and makes no API call. Agents should call it first in a new conversation, and whenever a request sounds outside Wevi's scope (for example "make a dance video").
The same statement is sent to the client as the server's instructions on connect, so assistants that honour MCP instructions already have it.
9a. wevi_list_brands
Brands saved on the account with website, logo and colors. Pass one as brandId to wevi_create_project to reuse it.
9. wevi_get_credits
Show the credit balance for the current key's account, which the studio spends from too. It returns plan (allowance, used, remaining, period), rolloverCredits, purchasedCredits, heldCredits, totalAvailable, paidAccess, costs (credits per action right now), team, and key (this key's own monthly cap). Takes no parameters. Call it before a large batch, or when a tool fails with 402. Credits are bought by the user in the Wevi app, under Profile → Billing.
💳 Credits
Live keys and connectors spend the same credits as the studio and the studio agent. There is no separate API bill.
| Action | Charged |
|---|---|
| Scene render: a new scene, or one changed since its last render | Per scene |
| Export | Per export, more at 1080p and more again at 4K |
Storyboard draft (wevi_generate_storyboard) | Per draft |
Page capture (wevi_capture_scene, wevi_capture_web_ui) | Per capture |
Live browser session (wevi_open_page) | Free for the first minutes, then per started block |
Creating a project, re-picking components (wevi_select_capture), sound changes | Free |
Prices and plan allowances change, so this page does not list them: costs in wevi_get_credits is what each action costs now. Free accounts get a one-time credit grant, for videos up to the free length at 720p with a watermark. Credit packs are the main way to buy more: they never expire and unlock 1080p and 4K, no watermark, longer videos, and your own music and voice; paid plans add a monthly allowance. Users buy credits under Profile → Billing in the Wevi app.
When an action cannot go ahead, the tool says why, with the numbers:
402 INSUFFICIENT_CREDITS: the credits needed, available and set aside for a video in progress.402 KEY_MONTHLY_CAP: this key reached its own monthly cap (set on the API Keys & MCP page).403 FREE_VIDEO_TOO_LONG: a free account's video runs past the free length; remove a scene.403 EXPORT_QUALITY_LOCKEDand403 FEATURE_NOT_AVAILABLE: the quality, music or voice asked for needs paid access.429: a sandbox allowance or the daily browser minutes ran out, with the reset time.
See API Keys & Credits.
🧪 Sandbox keys
With a wevi_test_ key every tool works the same, but renders are watermarked, exports are capped at 720p, and nothing counts against your credits. Status responses include sandbox: true.
Each test key has a hard daily allowance: 20 scene renders, 5 exports, and 4 scenes per project, resetting at 00:00 UTC. Past the cap, wevi_trigger_render returns a 429 message with the reset time.
🔐 Capturing Private & Authenticated Dashboards
Templates often need real product UI that sits behind a login. Wevi keeps the human in the loop:
- Never share passwords with an assistant. Agents are told not to ask for them, and Wevi never stores typed text in its logs.
- Log in once, in your own browser. Every page the agent looks at reports whether it is a sign-in screen (
authWall) and carriesloginUrl, a link of the formhttps://app.wevi.ai/browse/live?sessionId=…. When a page needs a login, the agent sends you that link; it opens the same cloud browser the agent is using. You sign in there (SSO and 2FA included) and press I am signed in. A sign-in window the site opens, such as Sign in with Google, Apple or Microsoft, shows on that page as a tab of its own, and the page comes back once the window closes. The agent waits withwevi_wait_for_login, then reads the app'sroutes(its own navigation: dashboard, reports, settings…) and captures the view the scene needs. A sign-in screen never costs a credit:wevi_capture_scenereturnsloginRequired: trueinstead of capturing the form. - Logins persist per account. The browser profile is kept for your Wevi account, so later captures from the same site are already signed in. The same profile is used by the capture browser inside the Wevi app.
- Reset any time. The Browser logins control on the API Keys & MCP page clears the stored browser profile.
- Sandbox keys never reuse logins.
wevi_test_keys always browse in a fresh, anonymous profile. - Guardrails. Agent steps cannot click anything that looks like a payment, purchase, deletion or account change, are limited to 12 per call and 150 per session, cannot open non-web URLs, and every step is recorded on the project (what was clicked or typed into, never the text).
Direct image fallback still works: drop a screenshot into the chat and ask the agent to use it as a plain image layer.
⚖️ Capture Methods Compared: Wevi Browser Engine vs. Chat Drag-and-Drop
| Feature / Capability | Wevi Browser Capture Engine (wevi_capture_scene) | Direct Screenshot Drag-and-Drop in Chat |
|---|---|---|
| Headline & Copy Extraction | ✅ Extracts clean text directly from the DOM | ✅ Claude OCRs visible text from the image |
| Brand Color Extraction | ✅ Reads computed CSS hex / RGB codes | ✅ Visual color sampling by the LLM |
| Static Full-Screen Mockups | ✅ Supported | ✅ Ideal use case for flat images |
| Text Punching / Erasure | ✅ Erases baked text so animated typing layers don't overlap | ❌ Text is baked into pixels |
| Precision Motion Coordinates | ✅ DOM bounding boxes feed camera & cursor motion | ⚠️ Estimation only |
| True Font Stacks & TTF Files | ✅ Extracts computed font-family, weight, and Google Font files | ❌ Not possible |
| Dynamic Border-Radius Masks | ✅ Applies computed CSS border-radius with alpha edges | ⚠️ Depends on the source crop |