Twin Browser
Platform
OverviewHow it worksREST APIMCP serverIntegrationsDocs
Capabilities
OverviewSemantic dispatch cacheDeterministic replayCross-tenant skill corpusToken-efficient DOMHuman-in-the-loopLive view & videoCredential vault
Solutions
All use casesAI agentsRPA replacementQA & test automationData extraction
Resources
GuidesGlossaryBlogCompareFAQStatus
Pricing
Log inGet an API key
Use case

Accessibility automation

Drive web tasks on a user’s behalf and audit pages for accessibility — over a token-efficient view of the live DOM.

Start freeHow it works

The problem

Inaccessible sites lock people out of routine tasks, and accessibility audits are slow, manual, and stale the moment the page changes. Both problems need something that can reliably understand and operate a live page on a user’s behalf — not a brittle script that breaks on the next redesign.

See how Twin works
app.example.com
  1. Open the page on the user's behalfdone
  2. Map interactive DOM elementsrunning
  3. Complete the task or auditqueued
  4. Hand off if a step needs a personqueued
  5. Record live view + videoqueued

A Twin run for accessibility automation — compile once, then replay on a cache hit.

The wedge

How Twin solves it

Twin’s DOM-to-indexed-state compiler turns a live page into a compact, structured map of its interactive elements, which is exactly the foundation both assistive task-completion and accessibility auditing need. You can compile a "complete this task for the user" flow into a replayable skill, or sweep pages and report on their interactive structure — all where you’re authorized, with audit logging on every call.

  1. 1Express an assistive task as a goal; Twin operates the live page over its indexed DOM map and completes it on the user’s behalf.
  2. 2Compile recurring assistive flows into skills so they replay deterministically and cheaply.
  3. 3Sweep target pages to surface their interactive structure for accessibility review.
  4. 4Pause for human-in-the-loop handoff whenever a step needs a person, then resume.
  5. 5Keep runs observable with live view and durable session video for review and evidence.
In practice

One call, then it gets cheaper

Operate a live page on a user's behalf, or sweep pages for their interactive structure — all over the same token-efficient view of the DOM.

run.tsts
import Twin from '@twin-browser/sdk';

const twin = new Twin({ apiKey: process.env.TWIN_API_KEY });

const run = await twin.agents.run({
  goal: 'Complete the appointment booking for the user',
  url: 'https://clinic.example.com',
  onBlocked: 'handoff',   // hand off to a person if a step needs one
});

console.log(run.status);       // 'completed'
console.log(run.domMap);       // numerically-indexed interactive elements
console.log(run.videoUrl);     // live view + durable recording for review

What happens on this call

  • Twin compiles the goal into a deterministic, replayable skill.
  • The next re-phrased request matches it in the semantic dispatch cache.
  • Matched runs replay with zero LLM calls — credits drop back toward ~1.
  • Every call is authenticated, billed, and written to the audit log.
Read the API docs
Under the hood

The machinery that bends the cost curve

Every use case runs on the same primitives — the wedge that makes browser work cheaper the more your agents run.

Semantic dispatch cache

Re-phrased requests fuzzy-match a skill you already compiled, so they skip the planner LLM entirely.

Learn more

Deterministic replay

Matched skills replay the same way every time — a pass is a pass, and the marginal cost trends toward zero.

Learn more

Token-efficient DOM state

A live page becomes a compact, numerically-indexed map of interactive elements instead of raw HTML.

Learn more

Human-in-the-loop handoff

Blocked steps — approvals, MFA on an authorized flow — pause for a person, then resume cleanly.

Learn more

The outcome

Assistive task-completion and accessibility auditing run on the same structured, token-efficient view of the page — illustratively turning manual, redesign-fragile audits into repeatable, replayable skills that stay cheap to run.

Go deeper

Glossary: DOM indexed stateGuide: How to give an AI agent a browserGlossary: Token-efficient DOM
FAQ

Accessibility automation on Twin — common questions

How does Twin help with accessibility?
Twin’s DOM-to-indexed-state compiler produces a structured, numerically-indexed map of a page’s interactive elements. That same map powers completing tasks on a user’s behalf and auditing pages for interactive structure, where you’re authorized to do so.
Is automated assistance allowed?
Twin automates the web where you’re authorized — first-party sites, operator-approved automation, accessibility, and authorized testing. The run’s target URL is the authorization signal, with auth, billing, and audit logging on every call.
Can recurring assistive flows be made cheap to run?
Yes. Recurring flows compile into skills that match the semantic dispatch cache and replay deterministically with zero LLM calls, so the marginal cost per run trends toward zero.
Related

More ways teams use Twin

AI agents

Give your LLM agent a real browser it can drive — and stop paying the model on every single run.

QA & test automation

Author end-to-end tests as goals, run them deterministically, and replay every failure as session video.

Internal workflow automation

Automate the internal tools and vendor portals that have no API — with audit logging and human approval built in.

Put accessibility automation on autopilot.

Start free, compile your first skill, and watch the marginal cost per run trend toward zero.

Start freeRead the guides