Changelog

You can now stop a run from contacting your user. Set interactions_suppressed when you start a task or workflow run, and Deck won’t send an MFA code or security question to anyone. This is useful for scheduled or background runs, where a code arriving on your user’s phone in the middle of the night would be unexpected.

• Pass interactions_suppressed: true to POST /v2/tasks/{task_id}/run or POST /v2/workflows/{workflow_id}/run. On a workflow run it applies to every step. It defaults to false.
• If an interaction needs a person, the run fails right away with interaction_suppressed. The credential stays valid.
• The setting is on the run, not the credential, so the same credential still works for live runs where your user is there to answer.
• Task run and workflow run objects include interactions_suppressed: true when it was set.

Documentation

Runs on a credential can now egress from a country you choose. Set geolocation.country on a credential to a two-letter ISO country code, and every task run on that credential gets a Deck IP in that country. Sources that check where a login comes from see the same country as your user.

• Set it when you create the credential, or change it later with PATCH /v2/credentials/{id}. Pass "geolocation": null to clear it, and Deck goes back to choosing the location.
• If a source refuses a task run because of where it comes from, the run fails with source_not_available and the message “The source website is not available in this region.” Deck never switches to another country.
• Available on Enterprise plans.

Documentation

Event destinations can now filter on what’s inside an event, not just its type. You can send task runs from one agent to their own destination, or route events from different agents to different environments, such as staging agents to a staging endpoint and production agents to production.

• Add an optional filter when you create or update a destination with POST or PATCH /v2/event-destinations. Deck checks it against each event payload and sends only the events that match, retries included.
• Filters are written against the event exactly as you receive it. For example, { "data": { "agent_id": "agt_a1b2c3d4" } } limits a destination to one agent’s task runs.
• Supported operators: $eq, $neq, $gt, $gte, $lt, $lte, $in, $nin, $startsWith, $endsWith, $exist, $and, $or and $not. Use $in to send several agents to the same destination.
• Combine a filter with events to receive only certain event types, such as task_run.*, from one agent.
• Sending a new filter replaces the old one. Send null or {} to remove it. Destinations without a filter work the same as before.
• A destination’s detail page in the Console now shows its filter.

Documentation

You can now get an agent ready before your user is. Start a session with a source_id, and Deck sends the agent to that source’s login page right away. When your user submits their credentials, run the task on that session, and the login starts with the agent already in place. This cuts latency on the first run.

Pass source_id to POST /v2/sessions, then pass the returned session_id when you run the task.

source_id is a hint, not a constraint. A run on the session can still target any source, and the agent goes wherever the run needs.

The Auth Component does this for you. When a user picks a source, the component prepares a session, and the verification run uses it.

Documentation

Events can now be delivered to two new event destinations: AWS EventBridge and Cloudflare Queues.

AWS EventBridge (aws_eventbridge) publishes events to an event bus. Pass a region and, optionally, an event_bus_name; without one, events go to the account’s default bus. Authenticate with an access key, or with temporary credentials and a session token.

Cloudflare Queues (cloudflare_queues) sends events as messages to a queue. Pass the account_id, the queue_id, and an API token with write access to Queues.

Create either one from the Console or the API, with the same event subscriptions and filters as any other destination.

Documentation

The Auth Component could already show a live view of the task runs it started. The new Live View Component does the same for runs you start yourself. Start a task run, workflow run, or session from your server and pass its ID to the component. Your users watch the browser live in your app and answer any MFA prompt or security question the run raises.

Attach at any point in the run’s life. A user who comes back to a pending MFA prompt sees it right away, and closing the component never stops the run.

Pass workflowRunId to follow a workflow from step to step, or sessionId to follow whichever run in a session is live.

Set interactions: "external" for a view-only screen, so a support agent can watch a customer’s run without answering their MFA prompts.

Documentation

Credentials can now use google_sso and apple_sso, so Deck can log in to sources where users sign in with Google or Apple. Pass the user’s Google or Apple Account email and password, and the agent signs in through the source’s “Sign in with Google” or “Sign in with Apple” button.

Create a credential with auth_method: "google_sso" or auth_method: "apple_sso" and auth_credentials: { "email": "...", "password": "..." }.

In the Auth Component, list the methods a source offers with authMethods in its sourceConfig entry. Google and Apple appear as buttons under the source’s own form, or on their own when they’re the only option.

The form names the provider, so users know to enter their Google or Apple login and not the source’s.

Documentation

When a source asks for an MFA code, a security answer, or an account choice mid-login, the Auth Component shows the message and field labels the agent writes. You can now replace them with your own text for each source, so the user sees instructions that match what the source is asking for, in their language.

Set interaction on a source’s sourceConfig entry to replace the message and any field’s label and placeholder, separately for MFA, security questions, account selection, and other interaction types.

Text can be a plain string or localized per language, so a fr-CA integration can show French instructions alongside the component’s built-in French text.

Use * as a default for every source, interaction type, or field you don’t name. Anything you don’t override keeps the agent’s wording.

Documentation

Organizations on Enterprise SSO can now turn on Directory Sync, so users added to or removed from Deck in your identity provider are added to or removed from your organization automatically.

Works with Okta Workforce, Microsoft Entra ID, Google Workspace, and any SCIM 2.0 provider.

Ask your Deck account team to enable it, then set it up from Organization Settings > Security.

Deprovisioned users are deactivated and signed out immediately.

Available on Enterprise plans. Requires an active Enterprise SSO connection.

Documentation

The Auth Component could already run a single task as soon as a user connected a credential. Now it can start a whole workflow. Pass a workflowId in place of taskId, and the component connects the credential, starts the run, and keeps the user in the flow while the steps run.

Choose how long the user stays with closeAfterStep: just the login step, a step partway through, or the whole run. Steps after it keep running in the background and report through events.

MFA prompts and security questions on any step before the close step are answered right in the component, and the live view follows the run from step to step.

The credential the user logs in with is used on every step automatically. Use workflowInput to collect or pass input for each step, or to keep a different credential on a specific step.

Documentation

Some sources only accept traffic from IP addresses on an allowlist, so task runs from Deck’s default IPs get turned away. You can now turn on static IPs for a source and every task run against it comes from a fixed range owned by Deck that the source can allowlist.

Deck provides the range of static IPs to add to the source’s allowlist, so it’s in place before the first task run. The range is the same for every source in your organization.

Turn it on for a source from the Console or the API. Every credential, task, and task run against the source inherits it.

Available on Enterprise plans as an add-on.

Documentation

Stored files used to stay until their retention period ran out. You can now delete one whenever you want, from the Console or the API with DELETE /v2/storage/{storage_id}. Deletion removes the file and its extraction, can’t be undone, and the storage ID stops resolving afterward. A storage.deleted event fires so you can clean up your own copies.

Documentation

When a run fails, or you just want the same result again, you had to rebuild the request and submit it as a new run. You can now rerun a finished run with one call and Deck reuses what the original ran with.

• POST /v2/task-runs/{run_id}/rerun creates a new run of the same task with the original input. Tokenized fields are replayed from their stored tokens, so you never have to touch the secure values.
• POST /v2/workflow-runs/{workflow_run_id}/rerun creates a new run of the same workflow with the original run’s per-step credential, source, and input overrides, including for steps that were skipped.
• Works great as a retry strategy when a task fails unexpectedly.

Rerun a task runRerun a workflow run

Some sources sit behind an access gateway like Cloudflare Access that turns away any request without a service token in its headers, so the browser never reaches the app’s own login page. You can now set those headers on the source and Deck attaches them to every request to that source before the first navigation. Once the gateway lets the browser through, the run continues with the user’s normal login.

• Set once on the source, from the Console or the API with headers on POST /v2/sources and PATCH /v2/sources/{source_id}. Every credential, task, and run against the source inherits them.
• Mark secret values as tokenized and they’re vaulted and never returned, the same way tokenized source fields work on credentials.
• Available on Enterprise plans as an add-on.

Documentation

Chain tasks into a single workflow and Deck runs the whole sequence for you. Steps run one after another in a shared session, so the agent signs in once and stays signed in across every step, whether that’s checking a hotel rate and rebooking at the lower price, or listing the accounts behind a utility login and fetching the latest bill for each one.

• Pass one step’s output straight into the next with {{ steps.extract_accounts.output.accounts }} references. Deck validates them against the task’s output schema when you save.
• Run a step only when a condition holds with if, or once per item in a list with for_each.
• Every workflow run reports each step’s status, output, and task runs in one place, with errors pinned to the step that failed.
• Create workflows from the API with POST /v2/workflows or from the Console.

Documentation

Mark a task as sensitive to keep its runs private in the console. When enabled, the console no longer shows the live browser view, the agent’s reasoning, or screenshots for that task’s runs, for every role in your org. Each hidden panel shows a clear sensitive-task state instead of the content.

• Set it via the API on task create or update, or toggle it in the console from the task’s settings
• Hides the live browser view, agent reasoning, and screenshots across task runs
• Run status, outputs, and interaction prompts (like MFA approvals) are unaffected

Setting up document extraction used to mean hand-writing JSON Schema in a settings input. The Console now has a dedicated designer for it, reachable from the task builder and from task settings.

• Describe the document in chat and the designer drafts the extraction schema, deduplication keys, and extraction prompt for you.
• Start from curated templates instead of a blank schema.
• Guidance in the editor checks your setup the same way the API does, so problems surface while you build instead of when a save is rejected.

Sources change their antibot defenses over time, so a source that ran cleanly for months can start failing with blocked errors. You can now ask Deck to take a fresh look: reset a source and Deck re-runs its antibot analysis.

Available from both the Console and API with POST /v2/sources/{source_id}/reset.

No gap while Deck re-learns: runs keep using the existing analysis until the new one is complete.

Documentation

The Deck docs are now a hosted MCP server at https://docs.deck.co/mcp. Connect it to Claude, Cursor, Codex, or any other MCP client and your AI tool can search the docs and read full pages while it works, instead of relying on training data or web search.

Quick setup: add the server from the context menu on any docs page, or point your client at the URL. Any client that supports streamable HTTP can connect.

Three tools: search the docs, read full pages as Markdown, and report incorrect or outdated documentation straight to the Deck team. The server also exposes the Deck skill as an MCP resource.

Docs only, read-only: the server has no access to your Deck account or your data, and it cannot call the Deck API.

Documentation

Credentials can now hold onto their login between task runs. Enable persistence on a credential and Deck saves the signed-in browser state a run establishes, cookies and device trust included, and restores it the next time that credential runs, even when that run starts in a fresh session. On sources that remember trusted devices, your users approve MFA less often and repeat logins get faster.

Opt-in per credential: flip it on in the Console, or pass persistence: { "enabled": true } when creating or updating a credential through the API. Every credential response echoes the setting back.

Disabling persistence deletes the saved state immediately; re-enabling starts fresh.

Saved state is encrypted with a per-credential key held in Deck’s vault and purged automatically after 45 days without a run.

Every source in the Console now has its own page. Open a source to see everything Deck knows about it in one place: its credentials, its recent task runs, and how it’s been performing.

Performance at a glance: success rate, task volume, and errors for the source, over a time range you pick.

Credentials and task runs are searchable and filterable right on the page, with links through to the full filtered lists.

The Auth Component can already run a task as soon as a user connects a credential. Now it can collect that task’s inputs too. Enable taskInput and the component reads the task’s input schema, presents the fields you choose to the user, and passes the values into the chained run.

Present fields, fill them silently from config, or mix the two: show a date picker, pass the account ID behind the scenes.

Supports the full input schema: text, numbers, booleans, enums, nested objects, lists, and file attachments.

Inputs marked as tokenized are masked in the form and vaulted on submission; values never touch URLs or logs.

Documentation

Ask about your Deck account without leaving Slack. Mention the Deck app or DM it to check task runs, credential status, and metrics in plain language, or ask how anything in Deck works and get answers sourced from the docs and changelog.

• Conversational and structured: ask naturally, or use /deck commands like /deck runs list --status failed for instant lookups.
• Thread-aware: one mention and it follows the conversation, answering follow-ups without being mentioned again.
• Safe for the whole team: each person connects their own Deck account, answers are scoped to their role and organization, and the app is read-only. It can never see stored secrets or change anything in your account.

Documentation

Storage files skipped by the Deck agent are now visible from both the API and Console. Each skipped file includes the task run ID where the storage item was first found by the agent and the original storage item ID to make retrieval easy.

For source websites that require additional authentication fields beyond or without username and password, the Auth Component now supports passing custom props to present and capture custom inputs from your users. These source fields build on Deck’s credential management and can be optionally tokenized and translated.

Documentation

Triggers let you schedule a task to run automatically across your connected credentials, without writing the fan-out logic yourself. Define a trigger once, pairing a schedule with a task and a set of credentials, and Deck creates and manages the runs from there.

• Cron scheduling: Set a schedule and timezone; Deck computes occurrences in local time, so DST and day boundaries behave as expected.
• Credential fan-out: Target an explicit list of credentials, or a credential_filter by source and status that resolves dynamically on every fire, so newly connected credentials get enrolled with no registration step.
• Skip conditions: Use skip_if to skip credentials whose most recent run already succeeded within a given window, cutting redundant runs and cost.

Triggered runs are normal task runs tagged with a trigger_id, and triggers emit their own lifecycle and fire events (trigger.created, trigger_run.completed, and others) into the existing events system.

Documentation

Visualize and track key metrics in your Deck Console. View success rate, task volume, credential creation, and errors with the ability to dive deep on each metric when you filter by agent, task, source, or error type.

In addition to traditional username and password, the Deck API now supports a new auth method of source_fields. This auth method is used for source websites that authenticate with custom values beyond username and password such as account number, client numbers, etc. The fields are completely customizable and may be tokenized. You can add up to 10 custom source fields on a credential.

Documentation

Every task run is now bounded by a timeout you control. Set settings.timeout_seconds on a task to specify the maximum wall-clock time a single run can execute before Deck stops it and fails the run with a timeout error. Leave it unset and the task falls back to your plan’s default.

Documentation

Deck now supports triggers: schedule a task to run automatically across every credential on a source, without building the orchestration yourself. A trigger ties a cron schedule to a task and a set of credentials, and Deck creates one task run per credential each time it fires, handling fan-out, skip logic, and observability for you.

• Schedules: Set a cron expression and timezone in condition, and the trigger fires on that cadence.
• Dynamic credential scope: Target credentials with an explicit credential_ids list, or a credential_filter by source_ids and status so newly connected accounts get runs automatically, no registration step required.
• Skip conditions: Use skip_if to skip a credential when its last run of the task already succeeded within a time window, cutting redundant runs.
• Concurrency control: Cap simultaneous runs per trigger with concurrency_max. Scheduled runs draw from their own capacity pool, so a large fan-out never delays on-demand runs.
• Full observability: Triggered runs are normal task runs tagged with trigger_id. Triggers emit lifecycle events (trigger.created, trigger.activated, trigger.deactivated) and fire events (trigger_run.completed, trigger_run.failed), and auto-deactivate after repeated failures.

Triggers documentation

GET /sources now accepts a search query parameter for finding sources by name or website URL. It performs a case-insensitive substring match, so you can look up a source without knowing its exact name. The Auth Component now also supports source search via this new query parameter.

The Deck Console now has an Agent Library: pre-built agent templates with ready-to-run tasks across categories such as Energy & Utilities, Spend Management, Agentic Payments, and Onboarding. Each task comes with a curated prompt, input and output schemas, and optional storage config, so you can browse the library in the console or load templates straight from your terminal.

Source fields can now be tokenized for credentials on Enterprise plans. For sensitive values like a social security number that shouldn’t sit in plaintext, declare the relevant keys in a tokenized array inside auth_credentials. Deck vaults those values at write time and restores them at dispatch, so the agent can use them on the source without the values ever appearing in API responses.

Non-tokenized source fields are stored in the clear and readable when you retrieve the credential.

Tokenized fields are removed from source_fields on read; only their key names appear in the tokenized array. Auth secrets like password are always vaulted regardless of tokenized.

The Auth Component now supports mode="interaction" for surfacing MFA codes, security questions, and other mid-run prompts directly in your UI, without prompting your user for credentials again. Pass a credentialId or sourceId alongside a taskId, and the component skips straight to firing the task run, rendering any interaction that comes back in place.

Documentation

Tasks now accept files as inputs. Declare a file field in a task’s input_schema and pass the file as base64 when running the task. Files up to 20MB are supported, and every file is malware-scanned before the run proceeds.

Two purpose values control what happens after upload. With attachment, the agent receives the file at run time and uses it on the source — uploading it to a portal, attaching it to a form, or referencing it while completing the task. With extraction, Deck processes the file directly against the task’s extraction_schema and returns structured JSON without executing the agent. Once a file has been uploaded, you can reuse it on future runs by passing its storage_id instead of the raw bytes.

Storage & document extraction documentation

Any input field on a Deck task can now be tokenized. Rather than limiting tokenization to a fixed set of fields, you choose exactly which inputs get protected. Sensitive values like account numbers, personal identifiers, or payment information stay encrypted and never appear in plaintext in logs, webhooks, or API responses.

• Field-level control: Tokenize any input field on any task. You decide what’s sensitive, not the platform.
• Universal coverage: Works across all task types and sources. No special configuration per integration.
• End-to-end protection: Tokenized values are encrypted at rest and in transit.

Available on Enterprise plans only.

Deck now offers a SKILL.md file that teaches AI agents how to build Deck integrations. The file bundles a product summary, API quick reference, decision rules, common gotchas, and a verification checklist into a single document your agent can load at runtime. Download it from docs.deck.co/skill.md and drop it into your agent’s skills directory.

The Events page now surfaces aggregate delivery metrics for your event destinations. At a glance, you can track total events, delivered count, failed count, success rate, and retries across all your agents and tasks. Filter by time range (24h, 7d, 30d, 90d) to spot delivery issues and monitor destination health over time.

You can now define exactly which fields Deck extracts from captured documents. Pass an extraction_schema in your task’s storage config as a JSON Schema, and Deck uses it to guide parsing. Instead of getting back whatever the document happens to contain, you get structured JSON matching the fields you specified, including nested objects and arrays like line items. Pair it with the optional extraction_prompt field to give the extraction model natural-language guidance for tricky documents.

Documentation

Stream your agent’s browser session in real time as it executes a task. Watch credential entry, page navigation, form interactions, and data extraction as they happen. Follow along with every step of the workflow instead of waiting for a session replay after completion.

A drop-in React component for secure credential capture and source authentication. <DeckAuthComponent /> handles source selection, username/password collection, MFA and security questions, and error states. Credentials go directly to the Credential Vault and never touch your systems.

• Live view: Pass taskRunView: "live" to show a real-time view of the agent working after credential submission, instead of a static status spinner.
• Session tokens: Create a short-lived token via POST /v2/token from your server and pass it to the component. All configuration lives on the component, not the token.
• Task linking: Pass a taskId to automatically fire a verification task run after credential creation. The component shows run status inline while the agent works.
• Update mode: Pass a credentialId to re-collect credentials for an existing credential instead of creating a new one.
• Theming and language: Full appearance customization (colors, borders, typography, logo) and fr-CA language support out of the box.

Install with npm install @deckco/auth.

Auth Component documentation

Credentials now support source_fields for passing additional login values beyond a username and password. If a source requires an account number, company ID, or similar field to authenticate, you can include them in auth_credentials.source_fields when creating or updating a credential.

source_fields composes with any auth_method. Values are encrypted at rest and redacted on read. At task run time, the agent resolves each entry by key into the login flow.

Credentials documentation

Deck API v2 is a ground-up redesign of the platform. New resource model, new credential management, new event system, new console. Everything that made Deck work, redesigned for an improved developer experience when operating agent infrastructure at scale.

Key improvements:

• More complete endpoint coverage: Every resource—agents, sources, credentials, sessions, tasks, events—has dedicated endpoints with prefixed IDs (agt_, src_, cred_, trun_).
• Typed input and output schemas: Tasks define explicit I/O schemas. Input is validated on submission, output is validated on completion. You get consistent, schema-validated JSON regardless of source.
• Credential Vault: Dedicated endpoints for storing, updating, and deleting credentials. Credentials are verified automatically on first use for a task, and incorrect credentials move to a queryable invalid state.
• Complete event system: Create multiple destinations (webhooks, SQS, Pub/Sub), subscribe to specific event types, track deliveries, and replay failures.
• Consistent error handling with improved clarity: Errors return a structured errors array with type, code, field, and message fields for deterministic recovery.

Deck v2 API documentation

Deck now supports automated parsing for fetched utility bills. When a document is found during a job run, Deck will structure the document contents as a JSON payload and send a DocumentExtractionSuccess webhook.

Replay and audit the work of your agents from the Deck Dashboard. Session replay captures screenshots of your agents work every 5 seconds and gives you a powerful way to track your integration and troubleshoot issues.

Creating a connection in Deck with the EnsureConnection job now optionally accepts an external_id input to link users in your own system to Deck.

The new dashboard gives you new insight and observability into your Deck integration.

• View, search, and filter for connections and job runs
• Debug easier with new connection logs
• View and download documents produced from jobs
• See all webhook deliveries and payloads
• New sandbox onboarding to create jobs more quickly

Retrieve the output of a job in addition to its status with the new GET /jobs/{job_id} endpoint.

Documentation

Cancel a running EnsureConnection job with POST /jobs/{job_guid}/cancel. This allows you to cancel a connection to a source.

The Deck API now supports idempotency keys, allowing you to safely retry requests without performing the same operation twice. Include an optional idempotency key header in your requests, and if a network error or timeout occurs, you can resend the same request with the same key.

Documentation

Added a new endpoint to check the status of a job. You can now retrieve the current status of any job using the GET /jobs/{job_guid}/status endpoint. This allows you to check a job’s status before a webhook arrives.

API Reference

This release introduces the CreateSource endpoint, enabling users to generate new sources directly through the API Reference without needing the Dashboard, with built-in validation for seamless job access.

We’ve also added Agent Warmup, allowing agents to pre-load pages for faster logins, and implemented an 8-hour session timeout that automatically retries stalled tasks to ensure continuous operation.

Additionally, EnsureConnection now supports Access Tokens for connections without user presence, and document uploads have been redesigned to improve privacy by requiring client-hosted file URLs, ensuring no sensitive data is stored internally.

Added encryption directly from the Dashboard, improved webhook and widget configuration, team name setup, and error message accuracy.

Launched the Deck Dashboard for AI Bot job creation, added file retrieval flows and widget connection, improved MFA handling, data formatting, sandboxing, job retries, and agent speed, with automatic HMAC key creation for new teams.

Released the Deck Product Framework for internet data operations, added job submission endpoint and webhooks, enhanced data support, reliability, AI generation, PDF automation, and login handling, migrated API to Kubernetes, and secured webhooks with HMAC.

Added new connection and sustainability endpoints, introduced studio file management and account switch endpoints, and deprecated the old /connection/get endpoint.

Added sustainability statement and account endpoints, enabled charge categorization support, and implemented various bug fixes.

Expanded MFA support, added new Link configurations and fields, introduced a “Connection completed” webhook, and updated responses for connection data.

Added interval data support, new Link widget upload and manual input options, a provider addition feature, a /connection/destroy endpoint, and dynamic sandbox data.

Improved Sherlock’s PDF extraction, launched interval data, added document upload and delegated connection APIs, enhanced data accuracy and support tools, and improved universal connectors.

Enabled document upload to JSON, enhanced delegated connection APIs and Sherlock accuracy, improved internal tools, and updated universal connectors.

Launched Connection Debugger in the Dashboard, improved the Core Connection Engine, upgraded Sustainability and Bill endpoints, and enhanced universal connectors.

Added webhook features, MFA and security question flows in Sandbox, dashboard auto-refresh settings, and related API endpoints.

Improved authorization speed, added Link configuration for skipping source selection, and launched the universal connector.

Updated Sustainability Data Table, improved PDF data extraction, and added sustainability invoice and charge endpoints.

Revamped the Sustainability Data Table format for better readability.

Launched Sherlock, Deck’s PDF data extraction accuracy tool.