Skip to content

Payload Reference

The complete field reference for POST /api/transactions. Jump to a section: required · credentials · databases · RDP · Kubernetes · HTTP · command & query filtering · check-in. For copy-paste payloads see Examples by protocol.

Creating a checkout

Method / PathPOST /api/transactions
Who can call itPrivate broker authority, an enabled external checkout token within its scope, or an independently authorized permanent-admin session. Temporary admin sessions cannot directly create checkouts.
Bodyapplication/json (fields below)
Success201 Created → {"status":"created","transaction_id":"…"}

A cluster token grants no public administration. The colocated broker uses its own private credential file. External checkout tokens grant scoped checkout management when enabled. See Authentication.

External checkout tokens

From v3.0.2, deployments with server.checkout_api_tokens.enabled: true accept X-Bridge-Broker-Token on the following HTTPS routes:

MethodRouteToken access
GET/api/broker/validateReports the token’s checkout group, roles, and protocols.
POST/api/transactionsCreates a checkout in the token’s group and scope.
GET/api/transactionsLists the group’s active checkouts within scope.
GET/api/transactions/{id}Reads an owned checkout within scope.
DELETE/api/transactions/{id}Checks in an owned checkout within scope.

The credential determines ownership. The checkout payload does not select a broker group. Existing transaction IDs cannot be overwritten. The token cannot manage checkouts from another group or the colocated broker.

Checkout tokens are separate from the token field below, which authenticates access to an individual checkout. For creation, rotation, and network restrictions, see Checkout tokens.

Required for every checkout

FieldTypeDescription
transaction_idstringYour unique ID for this checkout. Used to fetch or revoke it later, and in connect URLs.
usernamestringThe Britive user identity this checkout is for (the person connecting).
expires_atintegerExpiry as a Unix timestamp (seconds). Must be in the future, or the create is refused. After it passes, connections are refused and the grant is reaped.

Required for an access (user) checkout

FieldTypeDescription
protocolstringWhat to connect with: ssh, telnet, rdp, vnc (beta), k8s (alias k8sexec), http, mysql, postgres, cockroachdb, mssql, redis, mongodb, cassandra, oracle, netconf, restconf, winrm.
target_ssh_host_keystringRequired for SSH and NETCONF target verification unless the deployment explicitly allows unpinned targets. Obtain the target public host key through a trusted channel.
target_hoststringBackend hostname or IP. Required for http when target_password supplies a bearer token. Otherwise optional for http.
target_usernamestringThe backend account to log in as. Not required for http or password-only vnc targets.
target_portintegerBackend port. Required explicitly for HTTP bearer-token checkouts, from 1 to 65535. Other protocols have protocol defaults.

Common options (any access checkout)

FieldTypeDefaultDescription
record_sessionbooleantrueRecord this session. Send false to opt out (also disables live-view for it).
tokenstring-Per-checkout credential issued by the Britive platform; enables token-authenticated connect/review flows. Stored hashed; never returned.
native_authstringserver defaultHow the connecting user proves who they are to Bridge for native connections: ldap or bridge_credentials.
bridge_auth_passwordstring-The credential the user presents to Bridge. Required when native_auth: bridge_credentials, and required for native mongodb, whose SCRAM exchange cannot work without one. Encrypted at rest; never returned.
ldap_auth_passthroughbooleanfalseSign in to the backend with the user’s own directory identity instead of a stored credential. See directory credential passthrough for the protocols it covers and what it implies.
bridge_prompt_kb_layoutstringusKeyboard layout Bridge uses to read what is typed into its own in-session prompts (us or uk). Only affects native RDP sign-in forms, where Bridge interprets the keystrokes itself - set it when your users’ keyboards are not US, or a masked password will be mistyped.
paste_capturestringserver defaultWhat a paste into a browser session records: full (verbatim), redacted (secret-shaped spans masked), or metadata (size, line count and timing only). Overrides recording.paste_capture.
keystroke_capturestringserver defaultWhat typed input in a desktop (RDP) session contributes to Activity Search and SIEM export: redacted (secret-shaped spans masked) or off. Does not change the recording, which captures key events either way. Overrides recording.keystroke_capture.

Directory credential passthrough

ldap_auth_passthrough covers the case where a target grants access by directory group membership, so there is no account for anyone to store. Instead of a vaulted credential, Bridge signs in to the backend with the directory identity the user already proved to it.

It is off by default and set per checkout: handing a user’s directory password to a target is a decision about that target, not something to assume.

ProtocolHow the backend logs in
Native RDPThe directory password, giving a silent Windows logon (no sign-in form).
Native SSHThe directory password, when the user authenticated to Bridge with LDAP. If the user authenticated with a public key and the checkout has no backend credential, Bridge asks for the target password during SSH authentication.
Native NETCONFOffered after the checkout’s own credentials, so an explicit one always wins.
Native PostgreSQL / CockroachDBThe directory password, which the target must accept (ldap, password or md5 in pg_hba.conf; scram-sha-256 is not supported).
Native SQL ServerWindows Authentication. The password is used to compute the logon response and is never sent to the target.

A checkout that enables it may omit the credential its protocol would otherwise require - target_password, or private_key for SSH and NETCONF. target_username is still required: it names the backend account.

What to know before enabling it.

  • It applies to native connections only. Browser sessions use the separate password-prompt flow described below.
  • It requires native_auth: ldap (the default when LDAP is enabled). A bridge_credentials password or a per-checkout token is a Bridge-managed secret and is never forwarded - the checkout is rejected at creation if it asks.
  • Setting it on a protocol that does not support it is rejected when the checkout is created, rather than silently ignored.
  • Database checkouts require the client to connect with encryption. Bridge authenticates every native client and refuses to read a directory password off an unencrypted connection - sslmode=require for PostgreSQL, Encrypt=yes for SQL Server. Database checkouts without the flag are unchanged.
  • SQL Server targets must not enforce Extended Protection for Authentication (channel binding), which is off by default. Because Bridge terminates the user’s connection and opens its own to the target, channel binding cannot match and the logon is refused. Use a stored target_password for those targets.
  • Azure SQL is not covered - its Entra ID authentication is token-based.
  • The target’s directory must be the one Bridge authenticates against, or trust it. Otherwise every session is a failed backend logon, and repeated failures count toward account-lockout policy.

Browser password prompts

A browser RDP or Telnet session with no stored target password asks the user for one when the session starts. Browser SSH does the same when the checkout has no stored password or private key. Bridge sends the password in a POST request, encrypts it at rest, and binds it to a short-lived, single-use connect token. The session URL contains only the token, never the password.

Credentials (by protocol)

These are the secrets Bridge uses to reach the backend. They are encrypted at rest and never appear in any API response.

FieldTypeApplies toDescription
target_passwordstringvnc, all databases, restconf, winrm; one of this or private_key for netconf; optional for rdp, ssh, and httpBackend password. For http in v3.0.2, the raw bearer token without the Bearer prefix. VNC requires a vaulted password of 1 to 8 bytes. See directory credential passthrough for supported password alternatives.
private_keystring (PEM)ssh, netconfPrivate key for key-based backend login (use this or target_password).
user_public_keystringssh, netconfThe connecting user’s public key, used to authenticate them to Bridge. NETCONF runs over SSH and uses the same front door.
target_domainstringrdp, mssqlWindows/AD domain. On SQL Server it names the domain for Windows Authentication; you can instead put it in target_username as DOMAIN\user or user@domain.
kube_bearer_tokenstringk8sBearer token for the Kubernetes API (use this or the client cert pair).
kube_client_cert / kube_client_keystring (PEM)k8sClient certificate + key for mTLS to the Kubernetes API.
target_ca_certstring (PEM)mysql, postgres, cockroachdb, mssql, redis, mongodb, cassandra, oracle, http, restconf, winrm, vncCA certificate to trust for backend TLS.

Database options

FieldTypeApplies toDescription
target_databasestringmysql, postgres, cockroachdb, mssql, redis (db index), cassandra (keyspace); mongodb in the browser client onlyDefault database to connect to. The native MongoDB proxy ignores it and takes the database from the client’s own command.
target_tlsbooleanmysql, postgres, cockroachdb, mssql, winrm, redis, mongodb, cassandra, oracle, vncConnect to the backend over TLS (e.g. RDS/Aurora). WinRM requires HTTPS, and native PostgreSQL, CockroachDB, MSSQL, Redis, MongoDB and Cassandra require target TLS regardless of legacy false values.
target_tls_skip_verifybooleanmysql, postgres, cockroachdb, mssql, http, winrm, restconf, k8sSkip backend certificate verification for an explicit development exception. HTTP checkouts with a bearer token reject true.

Three of these fields reach past the databases. WinRM requires HTTPS, and target_tls_skip_verify also applies to WinRM, RESTCONF, Kubernetes exec and the HTTP proxy. The Applies to column is authoritative; the section heading is not.

You can also restrict which queries a database session may run - see command & query filtering. See also the Databases protocol reference.

Remote-desktop (RDP) options

RDP exposes the richest per-checkout controls - this is how you turn clipboard and file copy on or off per grant. These apply to both modes; note that native RDP is in beta and certain RDP features may not yet function as expected there.

Passwordless RDP checkouts. RDP is one of the protocols where target_password is optional, for “log in as yourself” flows - e.g. a Windows/AD account where access comes from directory group membership rather than a stored account. Omit it and the user supplies the credential at connect time:

  • Browser sessions prompt for the password in the page when the user connects.
  • Native RDP clients get a sign-in form drawn inside the session before the Windows target is dialed - domain, user name and password, with Tab/Enter/Esc and the mouse. What is typed goes straight to the target; it is not stored, and it is not part of the session recording.
  • Either, if the checkout sets ldap_auth_passthrough, can skip the prompt entirely for native connections and sign in with the directory password the user already gave Bridge.

The target must accept password authentication for that account.

FieldTypeDefaultDescription
rdp_securitystringanySecurity mode: any, nla, tls, or rdp.
rdp_ignore_certbooleanfalseSkip backend RDP certificate validation.
rdp_enable_drivebooleanfalseAllow file copy via a redirected virtual drive.
rdp_disable_copybooleanfalseBlock copying out of the session.
rdp_disable_pastebooleanfalseBlock pasting into the session.
rdp_clipboard_save_filesbooleanfalseSave the content of copied files to the recording (otherwise only metadata is logged).
rdp_clipboard_max_file_mbinteger100Maximum size of a single clipboard file (MB).
lock_blocks_screenbooleanfalseWhen a reviewer locks the session, cover the screen instead of just blocking input.
rdp_color_depthinteger16Color depth: 8, 16, 24, or 32.
rdp_server_layoutstringen-us-qwertyKeyboard layout.
rdp_timezonestring-IANA timezone for the session clock (e.g. America/New_York).
rdp_enable_wallpaper, rdp_enable_theming, rdp_enable_font_smoothing, rdp_enable_full_window_drag, rdp_enable_desktop_composition, rdp_enable_menu_animationsbooleanfalseVisual-fidelity toggles (off by default for performance).
rdp_disable_bitmap_cachingbooleanfalseTurn off bitmap caching (caching is on by default for performance).

Kubernetes (k8s) options

FieldTypeDefaultDescription
kube_api_serverstring-Required. Kubernetes API address, e.g. k8s-api:6443.
kube_namespacestringdefaultTarget namespace.
kube_containerstring-Target container (defaults to the pod’s main container).
kube_commandarray-Command to run, e.g. ["/bin/bash"]. Empty attaches to the running process instead.
kube_ttybooleanfalseAllocate an interactive terminal.

Web (HTTP proxy) options

FieldTypeDescription
capture_hostsarrayExact hostnames the user may reach through the proxy. Supply this and/or capture_subdomains.
capture_subdomainsarrayDomain suffixes the user may reach (matches the domain and any subdomain).
blocked_methodsarrayHTTP methods to deny, e.g. ["DELETE","PUT"] (CONNECT can’t be blocked).
sanitize_headers_extendarrayAdds header names to the recording’s redaction list for this checkout.
sanitize_query_params_extendarrayAdds query-parameter names to redaction.
sanitize_body_fields_extendarrayAdds JSON body field names to redaction.

The sanitize_*_extend lists only add to the server’s base redaction lists - a checkout can never remove something the server already masks. Requests to a host not in your capture lists are blocked. See HTTP Proxy.

For HTTP bearer injection in v3.0.2, set target_password, an exact target_host, and an explicit target_port. The host must be a hostname or IP, without a URL scheme, path, or wildcard. Capture scope still applies. Bridge sends the credential only to that HTTPS host and port, replaces client Authorization and Host headers, and verifies the target certificate. target_ca_cert can supply a private CA. target_username is unused.

An empty target_password preserves client-supplied destination authentication. With a bearer token, HTTPS interception remains required even when recording is disabled. See Use kubectl through Bridge.

Command and query filtering

Restrict which commands (shell protocols) or queries (databases) a session may run, using an allowlist or a denylist of names and/or regular expressions. The same four fields drive both:

FieldTypeDescription
allowed_commandsarrayAllowlist of base commands/keywords - only these may run.
blocked_commandsarrayDenylist of base commands/keywords - these are rejected.
allowed_patternsarrayRegex allowlist, matched against the full command/query line.
blocked_patternsarrayRegex denylist, matched against the full line (e.g. "rm\\s+-rf", "DROP\\s+TABLE").

Set any allowed_* list and the session runs in allowlist mode (deny by default - only matches pass). Otherwise, set any blocked_* list for denylist mode (allow by default - only matches are rejected). Set neither to leave filtering off.

The two modes are exclusive, not layered. In allowlist mode the blocked_* lists are never consulted, so combining them does not add a second line of defence: the allowlist is the whole policy. Put everything you want refused outside the allowlist rather than in a blocked_* list beside it. A rejected command/query is refused and marked in the session recording; in an interactive terminal the line is cleared and a [BLOCKED] notice is shown.

Applies to:

  • Shell protocols - ssh, telnet, k8s, netconf, winrm, restconf (native clients and in-browser terminals). The base “command” is the first word on the line (e.g. ls, kubectl).
  • Databases - mysql, postgres, cockroachdb, mssql, cassandra, redis, mongodb. The base “command” is the leading query keyword (SELECT, INSERT, DROP, …); patterns match the full query text. (| is treated as a SQL operator, not a shell pipe.)

Command filtering is not a security control. It is a convenience guardrail and an audit aid - a way to nudge well-intentioned users away from obvious mistakes and to flag notable commands in the recording. It must not be relied upon to prevent malicious or accidental damage to a target system.

Filtering inspects the command line as it is entered. Any user who reaches an interactive shell can defeat it through routine, well-understood techniques - subshells and pipelines, shell built-ins and aliases, scripts and interpreters (python, perl, sh -c …), an editor’s or pager’s shell escape, alternate paths or renamed binaries, and encoded or obfuscated input, among many others. Treating a command allow/deny list as a boundary would give a false sense of protection. Database query filtering inspects the parsed wire query, so it is harder to slip past than an interactive shell - but the same principle holds: it is a guardrail, not authorization.

Protecting a target is the job of controls the target itself enforces: least- privilege accounts provisioned per checkout (including scoped database roles and grants), network segmentation, the target OS/application’s own authorization, and time-boxed, fully recorded access. Use command and query filtering to complement those controls and improve the audit trail - never as a substitute for them.

Recording redaction override

FieldTypeDefaultDescription
redact_response_bodiesbooleaninherits server defaultFor winrm and restconf, force-on or force-off masking of secrets in recorded response/output bodies. Omit to inherit the server default.

Checking in (revoking)

Method / PathDELETE /api/transactions/{transaction_id}
Who can call itAdministrators only.
Success200 OK → {"status":"deleted","transaction_id":"…"}

Revoking removes the grant so new connections are refused and any lingering session is reaped by the watcher. To immediately terminate connections that are still live, also call a disconnect endpoint:

Both endpoints require owner or administrator authority. Send the authenticated browser session cookie:

terminal
# End every live session for a checkout (by transaction id)
curl -X POST -b cookies.txt \
  https://bridge.example.com/api/auth/checkouts/<transaction_id>/disconnect

# End one specific session (by session id)
curl -X POST -b cookies.txt \
  https://bridge.example.com/api/auth/sessions/<session_id>/end

A signed-in owner or administrator can call either endpoint from the web interface instead, using their session cookie. A checkout’s own bearer token works for that checkout only.

Access paths and Oracle options

FieldTypeBehavior
native_enabledbooleanOmit to retain the protocol default. Set false to prevent native admission.
browser_enabledbooleanOmit to retain the protocol default. Set false to prevent browser admission. At least one supported path must remain enabled. Deployment switches still apply.
target_databasestringRequired for Oracle. Service name by default, or SID when oracle_connect_type: sid.
oracle_connect_typestringservice_name by default, or sid.
oracle_redirect_targetsarrayUp to 32 exact { "host": "node.example", "port": 2484, "protocol": "tcps" } destinations. Redirects preserve transport and database identity. TCPS verifies every destination. Skip verification is refused with an allowlist.

Oracle requires vaulted target credentials. Native Oracle also requires explicit native_auth: bridge_credentials and bridge_auth_password. Browser-only MongoDB needs no native Bridge password. See Oracle beta.

VNC beta options

VNC beta is opt-in for development and testing, disabled by default and not production-ready. Both access paths default to port 5900. The target requires a separate vaulted target_password of 1 to 8 bytes and does not use target_username. The Bridge or LDAP login password has no eight-byte limit and is never forwarded to the target.

Native viewers require VeNCrypt X509Plain and a trusted Bridge certificate. Use native_auth: bridge_credentials with bridge_auth_password, or native_auth: ldap for directory authentication. Deployment switches and checkout native_enabled and browser_enabled flags must permit the selected path.

target_tls: true performs TLS before the target RFB handshake and verifies the target hostname. target_ca_cert supplies a private CA. VNC refuses target_tls_skip_verify, anonymous target authentication, and command filtering. Clipboard transfer, file transfer, and live-view sharing are unavailable. See the VNC checkout example.

Last updated on