Open App Bridge (OAB) is an open specification for user-mediated content handoff between applications. No central registry, no OAB content relay, explicit transfer methods, and preview before preserve.
Awaiting Handoff
This is an explanatory UI walkthrough. Use the live sender below to execute the real protocol.
Many integrations depend on vendor-specific accounts, registries, and content services. Open App Bridge lets independent applications discover each other by domain and exchange content through explicit browser-native profiles.
OAB never sends shared payloads to an OAB service. The private profile uses an encrypted, direct data channel; the portable profile carries bounded non-confidential text in a URL fragment that the receiver scrubs immediately. Each application still serves its own pages.
Incoming data is never silently written to disk or database. Receivers mount an ephemeral, in-memory preview so the user can inspect the document before deciding whether to commit or discard it.
OAB is a protocol specification with a zero-runtime-dependency reference SDK. Use the
drop-in <oab-share>
component or implement the complete discovery, security, lifecycle, and transport contracts yourself.
The framework-neutral widget works with React, Vue, Svelte, Angular, Lit, Solid, or vanilla HTML.
Receivers opt in with bounded JSON at
/.well-known/open-app-bridge
without proprietary API keys, central registration, or platform sign-up.
A predictable discovery, transfer, and preview lifecycle that keeps both applications decoupled and the user in command.
The sender fetches the receiver’s exact HTTPS well-known declaration without credentials or redirects, validates its limits, and shows only advertised compatible profiles.
A separate user action launches either an encrypted private data channel or a bounded non-confidential text link. OAB never silently falls back from one profile to the other.
The receiver asks once, renders an inert transient preview, and writes nothing until the user chooses Preserve. Discard closes the preview without saving the content.
Install the published, versioned SDK. Senders add one component; receivers connect the explicit preview-and-preserve lifecycle while the SDK owns the protocol mechanics.
<!-- index.html -->
<article id="document">…</article>
<button id="share-document" type="button">Share</button>
<oab-share
trigger="#share-document"
content-selector="#document"
source-application="Example Writer"
></oab-share>
<script type="module" src="/src/app.js"></script>
// src/app.js — bundle with your normal application build
import "open-app-bridge/widget";<!-- No build tool: exact version + published SRI -->
<article id="document">…</article>
<button id="share-document" type="button">Share</button>
<oab-share
trigger="#share-document"
content-selector="#document"
source-application="Example Writer"
></oab-share>
<script
type="module"
src="https://cdn.jsdelivr.net/npm/[email protected]/dist/oab-widget.min.js"
integrity="sha384-yhugrnzA2IUCOWqa/f6CbiPIcRNXLkRHIj+w4428vcLmXAA/TSLHC6KUQA+CNs5W"
crossorigin="anonymous"
></script>// receiver.js — called by the required parser-blocking scrub-first shell.
// Start from the complete receiver example linked below; do not defer URL scrubbing.
import { consumeIncomingHandoff } from
"open-app-bridge";
export function installReceiver(scrubbedHandoff) {
return consumeIncomingHandoff(currentDeclaration, {
scrubbedHandoff,
admitIncomingHandoff: admitReplayAndPendingLeaseAtomically,
reserveIncomingBytes: reserveAggregateBytesAtomically,
authorizeSender: askOnceForUnverifiedText,
deliver: showTransientTextPreview,
authorizeOrigin: authorizeVerifiedOrigin,
authorizeManifest: applyManifestPolicySilently,
onPreview: showTransientPrivatePreview,
});
}// Serve as application/json at /.well-known/open-app-bridge
{
"protocol": "org.openapp.bridge",
"wireVersions": ["1.0"],
"status": "enabled",
"endpoint": "/_oab/receive",
"intents": ["preview"],
"transports": {
"link-envelope/1": {
"representations": ["text/markdown", "text/plain"],
"assetTypes": [],
"limits": {
"maximumUrlBytes": 16384,
"maximumFragmentBytes": 12288,
"maximumDecodedBytes": 8192
}
}
},
"senderPolicy": "ask",
"declarationId": "deployment-2026-09-04-a",
"discoveryTtl": 300,
"applicationManifest": "/manifest.webmanifest"
}Live web applications that support direct, client-side document handoff. Test cross-app transfers in real time or add your own app.
Distraction-free markdown workspace and visual canvas editor. Implements both current OAB profiles with one consent decision, inert transient preview, and explicit Preserve or Discard.
Have you built a markdown editor, diagram board, note-taker, or spreadsheet? Implement the OAB receiver specification and share your work with the community. This editorial list is not a protocol registry and is never consulted during discovery.
This is the real framework-neutral OAB sender. It discovers the domain you enter, shows only compatible advertised profiles, and prepares a one-shot native Send action. Try markerpad.app as a live receiver.
Clear answers to technical, architectural, and security questions about Open App Bridge.
Open App Bridge (OAB) is an open, vendor-neutral web protocol and reference SDK that allows independent web applications to exchange documents and application state directly in the browser. It eliminates the need for proprietary platform APIs, central user accounts, or intermediary relay servers.
Traditional web app sharing requires users to authenticate with a central platform, store files on third-party cloud infrastructure, and manage access tokens. In contrast, OAB operates entirely peer-to-peer at the browser layer. Senders discover receiver capabilities via standardized well-known endpoints, and users authorize direct handoffs without storing content on an OAB server.
No. OAB has zero relay servers and no central directory. Every application serves its own standard HTTPS declaration at /.well-known/open-app-bridge. Discovery is purely domain-to-domain, meaning there is no single point of failure, no toll booth, and no centralized tracking.
User safety is the core design tenet of OAB. Incoming shared data is never silently persisted to disk or database. Conforming receivers render an inert, transient preview in memory, giving the user explicit control to inspect the source application and content before deciding to Preserve (commit) or Discard (close).
OAB specifies two distinct transfer profiles:
1. Private Profile: An encrypted, direct peer-to-peer data channel backed by a hardened callback route for sensitive or confidential payloads.
2. Portable Profile: A link-envelope carrying bounded, non-confidential text inside a URL fragment that the receiver scrubs immediately upon mounting.
OAB never silently falls back between profiles; the user always chooses the explicit transfer method.
To act as a sender, install the exact open-app-bridge npm version and import open-app-bridge/widget, or use the minified standalone widget with the release's SRI value. To act as a receiver, publish a JSON declaration at /.well-known/open-app-bridge, bundle the SDK into your own first-party resource graph, and implement the complete preview-and-preserve lifecycle.
We aren’t a tech conglomerate trying to force an ecosystem standard. We are developers who believe web applications should speak to each other effortlessly, without toll booths or privacy sacrifices. Read the draft specification, poke holes in the security model, and tell us how to make it better.