Twin Browser
Get an API key
PlatformOverviewHow it worksAll toolsREST APIMCP serverIntegrationsDocs
CapabilitiesSemantic dispatch cacheDeterministic replayCross-tenant skill corpusToken-efficient DOMHuman-in-the-loopLive view & videoCredential vaultOverviewSolutions
SolutionsAll use casesAI agentsRPA replacementQA & test automationData extraction
ResourcesGuidesGlossaryBlogCompareFAQStatus
Pricing
Log in

Use case

Internal workflow automation

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

Start freeHow it works

The problem

What the status quo costs you.

Most internal operations run on tools that never shipped an API: legacy admin panels, vendor portals, insurance and procurement systems. Teams automate them with fragile scripts or armies of contractors, and either way there’s no clean audit trail and no safe place to pause for a human approval.

See how Twin works
app.example.com
  1. Open the internal admin paneldone
  2. Resolve service credentialsrunning
  3. Run the compiled workflow skillqueued
  4. Human approves the gated stepqueued
  5. Write the run to the audit logqueued
A Twin run for internal workflow automation — compile once, then replay on a cache hit.

The wedge

Compile once. Replay forever.

Twin automates first-party and operator-approved internal workflows where you’re authorized, treating the run’s target URL as the authorization signal and logging every call. It compiles each workflow into a replayable skill, holds credentials in the vault, and pauses for human-in-the-loop handoff on approvals or MFA — then resumes. Because it’s a multi-tenant backend with default-deny RLS, per-tenant API keys, and an audit log, it fits internal-ops governance rather than fighting it.

  1. 1Compile each internal workflow into a skill from a plain-language goal — no API required on the target system.
  2. 2Store service credentials in the per-tenant credential vault instead of in scripts.
  3. 3Insert human-in-the-loop handoff at approval and MFA gates; the run pauses and resumes cleanly.
  4. 4Every call is authenticated, billed, and written to the audit log for governance.
  5. 5Repeated runs hit the semantic cache and replay deterministically, so recurring back-office work gets cheaper over time.

Outcome · Back-office work that once needed brittle scripts or manual labor becomes a set of governed, replayable skills — illustratively cutting per-run cost as the same workflows recur, with a full audit trail and clean human checkpoints.

In practice

The actual call, and what it returns.

The credential goes into the vault once and is referenced by name. The run carries the reference, not the secret, and stops for a person at the gate you nominate.

Vault + runapprove-po.shbash
# Write-only: GET /api/v1/secrets returns names, never values.
curl https://twin-browser.com/api/v1/secrets \
  -H "Authorization: Bearer $TWIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "OPS_PORTAL_PASSWORD", "value": "…" }'

# Reference it by name in the goal; the run resolves it server-side.
curl https://twin-browser.com/api/v1/run \
  -H "Authorization: Bearer $TWIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://admin.internal.example.com",
    "prompt": "sign in as ops@acme.com with {{secret:OPS_PORTAL_PASSWORD}} and approve purchase order 4471",
    "success": { "kind": "textVisible", "value": "Approved" },
    "hitl": true
  }'

# → 200 { "success": true, "steps": 11, "runId": "…", "credits_charged": 10 }
# → or  { "status": "paused", "challenge": "app-approval" }  <- a person decides

What this call does

  • The target system needs no API: the run drives its live UI the way a person would.
  • {{secret:NAME}} is resolved for this tenant, host and account at call time — the value never returns in a response.
  • "hitl": true parks the run on an approval or 2FA wall so a person can act, then it resumes from where it stopped.
  • Auth, metering and an audit record run on every call, including the paused and resumed halves.
Every endpoint, every field

Under the hood

The machinery under every run.

Every use case runs on the same primitives: a token-efficient view of the page, deterministic replay, and a checkpoint where a person decides.

Semantic dispatch cache

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

Read the mechanism — Semantic dispatch cache

Deterministic replay

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

Read the mechanism — Deterministic replay

Token-efficient DOM state

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

Read the mechanism — Token-efficient DOM state

Human-in-the-loop handoff

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

Read the mechanism — Human-in-the-loop handoff

FAQ

Internal workflow automation on Twin — common questions.

What about tools that have no API?
That’s the core case. Twin drives the browser the same way a person would — over the live UI — so internal admin panels and vendor portals with no API become automatable through a compiled skill.
Is this authorized to run on our internal systems?
Twin automates the web where you’re authorized — first-party sites, operator-approved automation, and internal RPA. The run’s target URL is the authorization signal, and auth, billing, and audit logging run on every call.
How are approvals handled?
Blocked steps — approvals or MFA on an authorized flow — trigger human-in-the-loop handoff. The run pauses for a person to act, then resumes automatically, with the handoff recorded in the audit log.

Related

More ways teams use Twin.

RPA replacement

Replace brittle, selector-keyed RPA bots with skills that adapt to the page — you authorize the run, the agent does the work.

AI agents

Give your AI agent a real browser it can drive — reach any site, act under your guardrails, and let repeated work replay at near-zero cost.

Accessibility automation

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

Put internal workflow automation on autopilot.

Start free, hand your agent the work under your guardrails, and let the runs you repeat replay from a compiled skill.

Start freeRead the guides