Adobe’s Embedded Design Editor (EDE) exposes optional callbacks for loading, cancellation, publishing, errors, host events and workflow changes. The main callbacks to handle are onLoad, onCancel, onPublishStart, onPublish and onError. Use onEvent only for supported host messages; its documented type reference does not provide a complete event-name catalog. Although the CC Everywhere callback interface includes onIntentChange, Adobe’s EDE guide says it is not operational for EDE workflows today.
How EDE workflows and callbacks fit together
EDE provides two documented module workflows: module.createDesign() starts a design from a template or blank canvas, while module.editDesign() reopens and refines an existing document. Both use appConfig, exportConfig and containerConfig. The edit workflow also accepts docConfig for the document to preload. These configuration objects set up the editor; callbacks are the host application’s way to react to lifecycle and user actions.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Adobe XD Classroom in a Book (2020 release) | $43.43 | Buy on Amazon |
| 2 |
|
Adobe XD CC Classroom in a Book (2019 Release) | $57.99 | Buy on Amazon |
| 3 |
|
Adobe Creative Cloud All-in-One For Dummies (For Dummies (Computer/Tech)) | $34.52 | Buy on Amazon |
| 4 |
|
Jump Start Adobe XD | $27.90 | Buy on Amazon |
| 5 |
|
Adobe XD CC Classroom in a Book (2018 release) | $10.24 | Buy on Amazon |
The current callback model is the CC Everywhere Callbacks interface. Every callback in that interface is optional, so a host can implement the events relevant to its workflow rather than supplying empty handlers for all of them. In practice, a host should decide which state transitions matter—readiness, cancellation, export progress, a completed save, and errors—and keep those transitions distinct.
Callback reference: what fires and what the host receives
| Callback | When it may be invoked | Payload or return | Useful host response |
|---|---|---|---|
onLoadInit |
When the target application starts loading and the spinner starts. | LoadInitCallback payload. |
Show the initial loading state. |
onLoadStart |
When target application loading starts. | LoadStartCallback payload. |
Start a loading timer or record a telemetry milestone. |
onLoad |
When target application finishes loading. | LoadCallback payload. |
Enable host controls that require a ready editor. |
onCancel |
When the user cancels the workflow. | isEscapePressed: boolean. |
Close or reset host workflow state; retain whether Escape caused cancellation. |
onPublishStart |
When the user starts export by clicking a save button. | Optional exportButtonId: string. |
Mark export as in progress and, if supplied, identify the selected export action. |
onPublish |
When export finishes. | (intent, publishParams); may return void or Promise<PublishStatus>. |
Process the result and return the appropriate save status. |
onError |
In error scenarios. | error: CCEverywhereError; returns void. |
Show an actionable message and log diagnostic details. |
onEvent |
For information-style host events. | message: HostEventData; returns void. |
Handle the host event types your integration supports. |
onIntentChange |
When a user navigates from one design workflow to another, such as Quick action to Express. | (oldIntent, newIntent); may return IntentChangeConfig to update app, export or container configuration. |
Potentially adapt configuration, but do not rely on this callback in EDE workflows today. |
The load callbacks describe different milestones, not interchangeable synonyms. Use onLoadInit for initial visual feedback, onLoadStart if the host needs a start timestamp, and onLoad for readiness-dependent controls. The documented wording says these callbacks may be invoked; avoid treating a callback as a guarantee that every workflow will trigger each earlier milestone.
#1 Best Overall
Handle completion and cancellation as separate outcomes
Cancellation
onCancel signals that the user canceled the workflow and supplies a boolean, isEscapePressed, to distinguish Escape-key cancellation. Use the callback to unwind host-side UI state—for example, dismiss a host-owned progress or modal state—and record the cancellation reason if that distinction matters to your product. Cancellation is not an export result, so do not treat it as a successful publish with missing asset data.
Export start
onPublishStart is associated with the user starting export by clicking a save button. Its exportButtonId is optional. The host can mark the operation as pending at this point, but should not treat the start callback as confirmation that an asset has been produced; completion is handled separately by onPublish.
Export completion and returned status
onPublish receives an intent and publishParams. Adobe’s tutorial demonstrates storing publishParams.documentId so the same design can later be reopened through module.editDesign({ docId }). It also reads publishParams.assetPreview[0].data to display a preview, then returns { status: "SUCCESS" } to acknowledge the save. The callback may return synchronously or return a promise resolving to a PublishStatus; use the asynchronous form when host-side processing must finish before returning a status.
The tutorial’s export configuration demonstrates PDF and PNG publish actions. Full-resolution output can be supplied as a URL or blob, while an optional preview can be supplied as base64. These are payload-format choices: a preview is not the same thing as the full-resolution exported asset. A host that persists the design should retain the document identifier separately from any asset or preview data it processes.
Implement the callbacks your host needs
The following handler bodies show the documented payload fields and a success status from Adobe’s tutorial. They are JavaScript examples, not a complete EDE bootstrap: the exact SDK setup and the point where your integration passes its callback configuration are not specified here. Connect the handlers through the callback configuration supported by your EDE integration, and use its type definitions for the full payload shapes.
function handleLoad() {
setEditorReady(true);
}
function handleCancel(isEscapePressed) {
closeDesignWorkflow();
recordCancellation({ isEscapePressed });
}
function handlePublishStart(exportButtonId) {
setExportPending(true);
if (exportButtonId) {
recordExportAction(exportButtonId);
}
}
async function handlePublish(intent, publishParams) {
const documentId = publishParams.documentId;
saveDocumentId(documentId);
const preview = publishParams.assetPreview?.[0]?.data;
if (preview) {
displayPreview(preview);
}
await processExport({ intent, publishParams });
return { status: "SUCCESS" };
}
function handleError(error) {
showActionableError(error);
logEditorError(error);
}
function handleEvent(message) {
handleSupportedHostMessage(message);
}The host functions in this example (setEditorReady, closeDesignWorkflow, and the others) represent application-specific behavior, not EDE APIs. Adapt preview handling to the payload actually returned by your chosen export configuration; the example uses optional chaining because the preview is optional. If your host does not need a particular callback, omit it rather than inventing a handler for an event the integration does not use.
Rank #4
What to do with generic events and workflow changes
onEvent receives a HostEventData message and is intended for information-style host events. The cited type reference does not list every event name or define a complete catalog. Avoid writing a handler that assumes undocumented message names. Instead, handle only the message types supported by the EDE version and integration you use, and make unknown messages non-fatal.
onIntentChange has a broader CC Everywhere callback shape: it receives oldIntent and newIntent and may return an IntentChangeConfig that updates app, export or container configuration. However, Adobe’s EDE guide says this callback is not operational for EDE workflows today. Treat its presence in the interface as type-level capability, not as a working EDE workflow hook.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsPractical integration checks and troubleshooting
- The editor appears ready before host controls work: enable controls that depend on editor readiness from
onLoad, rather than from the initial loading callback. - The host sees an export start but no completed asset:
onPublishStartindicates the user started export, not that it finished. Keep pending and completion handling separate, and useonPublishfor the completion payload. - A preview is missing: the tutorial treats
assetPreviewas available for its preview example, but previews are optional in export configuration. Do not make successful document handling depend on preview data unless your configuration requires it. - A design cannot be reopened: preserve
publishParams.documentIdon publish and pass the identifier tomodule.editDesign({ docId })when reopening; do not substitute preview data for the document ID. - Cancellation is logged without its cause: capture the
isEscapePressedboolean fromonCancelif the host needs to distinguish Escape from another cancel action. - A generic event handler receives an unfamiliar message: the documented type page does not establish a complete event-name catalog. Ignore or safely log unsupported messages rather than assuming a name or payload shape.
- Intent-change handling never runs: this is expected for EDE workflows according to Adobe’s guide; do not make successful integration dependent on
onIntentChange. - An error handler is expected to return a status:
onErrorreturnsvoid. Keep error reporting and diagnostics there; publish acknowledgement belongs toonPublish.
Keep lifecycle telemetry useful
For timing, record the load milestones separately rather than collapsing them into a single “loaded” value. For export observability, record a start at onPublishStart and completion when onPublish runs. For support diagnostics, capture the CCEverywhereError data provided to onError and any supported host-event information you actually consume. Avoid logging full exported assets or base64 previews when the host only needs a document identifier or outcome; the callback data can include content, not just status.
ScreenshotNeo for a separate screenshot-capture need
ScreenshotNeo is not an embedded design editor and does not emit EDE lifecycle callbacks. If the adjacent task is capturing a webpage or an exported design displayed on a page, it is the screenshot API alternative to try first: it removes consent banners, newsletter popups and chat widgets before capture; bot checks, blank pages and failed loads are never billed; it has an MCP server for AI agents; and the Free plan includes 1,000 screenshots per month with no card, while paid plans start at $5 for 3,000. See the ScreenshotNeo API documentation.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpOne GET request returns an image or PDF; the API supports PNG, JPEG and WebP screenshots as well as PDF output. The cURL example captures the page at https://stripe.com; replace that target with the webpage you need to capture and use your API key. Sign up for ScreenshotNeo: 1,000 screenshots a month free, with no card required.
Frequently Asked Questions
Does every EDE callback have to be implemented?
No. The CC Everywhere Callbacks interface marks all callbacks as optional.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Does onPublish return the exported file itself?
It receives intent and publishParams, which can carry document and asset information configured for the export. The callback’s return is a publish status or promise of one, not the file.
Can I rely on onIntentChange to switch EDE workflows?
No. Adobe’s EDE guide says onIntentChange is not operational for EDE workflows today.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
