Skip to main content
Deck agents log in, navigate, and operate software exactly like a human does, whether the target service has an API or not. No data migration, no custom connectors, no integration limits. If your team can use it, Deck can automate it. You make API calls, and Deck handles the browsers, authentication, page navigation, data extraction, and structured results.

​
Architecture

Every operation follows this pattern. Your application talks to the REST API. The API validates the request, queues the work, and delegates to a managed browser agent. The agent does the work and reports back through events.

​
Browser orchestration

Deck provisions isolated browser sessions on demand. One agent or thousands, same deploy. When you open a connection or run a task, Deck spins up a browser, routes it to the target website, and executes the required actions. No config changes, no re-architecture.

​
Session management

Browser sessions are tied to connections. When you open a connection, Deck authenticates the user to the target website and keeps the session alive. Subsequent task runs reuse the authenticated session without re-login. Sessions persist across task runs and time out after a period of inactivity. When a session times out and the browser is closed, Deck sets the connection to disconnected and emits a connection.disconnected event so your application can react.

​
Execution model

All work in Deck is asynchronous. When you call the API to open a connection or run a task, you get an immediate response with a connecting or queued status. The actual work happens in the background.
1

Request

Your application calls the Deck API with the required parameters. Deck validates the input against the task’s schema and rejects malformed requests synchronously.
2

Execute

Deck assigns an agent, which navigates the target website and performs the defined actions: clicking, typing, reading, downloading.
3

Return

The agent extracts data according to the task’s output schema. Deck validates the output, stores it on the task run, and emits a completion event.

​
Deterministic output

Websites are messy. Layouts change, elements shift, and content varies by locale. Deck isolates your application from all of this. Task runs include screenshots and reasoning traces so you can see exactly what happened. Every task defines an input schema and an output schema. Regardless of how the underlying website renders its data, Deck returns a consistent JSON structure. Fields marked as required in the output schema must be present for the task run to succeed. If the agent can’t extract a required field, the run fails. Optional fields may be null if the data isn’t available. This contract means you write your integration code once and it works across sources. A “fetch reservations” task returns the same shape whether the source is Hilton, Marriott, or Hyatt.

​
Handling interactions

Some operations require human input midway through execution. MFA codes, security questions, and other verification prompts. The agent can’t proceed without your user’s involvement. When this happens, Deck pauses the browser agent and notifies your application:
  1. The agent encounters a prompt it can’t resolve autonomously
  2. Deck sets the status to interaction_required and emits an event
  3. Your application collects the required input from the user
  4. You submit the input via the interaction endpoint
  5. The agent resumes exactly where it left off
The browser session stays open while waiting.

​
Event-driven integration

Deck is built for event-driven architectures. Rather than polling for status changes, you register event destinations and Deck pushes events to your infrastructure as they happen. Events cover the full lifecycle: connections opening and closing, task runs starting and completing, interactions required, deliveries failing. Every event includes the full object payload so your handler has the context it needs without additional API calls. Deck delivers events to webhooks, AWS SQS, GCP Pub/Sub, and other cloud-native destinations, with built-in retries and delivery tracking.

​
Next steps

Quickstart

Create an agent, connect a user, and run your first task.

Concepts

Agents, sources, connections, tasks, and how they fit together.

Building your auth flow

Collect credentials, handle MFA, and manage connection state.

Using the API

Authentication, pagination, idempotency, and error handling.