Start customer designs from the master with overwrite=false so one customer does not replace the shared starting template.
Saved-document integration
Save and reopen embedded editor documents
Give customers a design they can return to. Connect the editor's saved-document webhook to your backend, keep the customer copy separate from the master template, and reopen the editable result instead of a flattened image.
A saved design is more than an export
Keep the document identifier or editable HTML alongside the generated image and the customer record that owns it.
Persist the editable document, not only the PNG
For documents saved in Pixelixe, keep document_uid from the editor webhook and reopen that authorized customer document with overwrite=true. For editable HTML stored on your own server, use graphicUrl and the documented CORS headers. A PNG or JPEG is a final image, not the layered document used for continued editing.
Save the returned customer document UID and relevant URLs in your own authorized application records.
Reopen the saved UID or editable HTML and validate a second edit before treating the integration as complete.
Choose how to reopen the document
The storage path determines which value your application passes back to the editor.
| Stored item | Reopen with | What it preserves |
|---|---|---|
| A saved Pixelixe customer document | document_uid and overwrite=true. | The saved document that the customer can continue editing. |
| An editable HTML document on your server | graphicUrl pointing directly to the HTML document. | The editable document, with the required accessibility and CORS configuration. |
| A PNG or JPEG export | Use as a finished image, not as the original editable document. | The rendered appearance, not the original text and image layers. |
| The master template UID | overwrite=false for a new customer design. | The reusable starting point; persist the returned customer copy separately. |
| A generated HTML variant | The documented HTML output URL through graphicUrl. | An editable generated variant rather than only a final bitmap. |
Connect the saved result to the next session
The webhook example shows the documented fields your endpoint receives. The URL builder demonstrates reopening a saved customer document; authorize the document before supplying these values.
Webhook
Illustrative saved-document payload
{
"status": "success",
"user_uid": "customer_42",
"document_uid": "CUSTOMER_DOCUMENT_UID",
"document_name": "Customer campaign",
"public_png_url": "https://studio.pixelixe.com/storage/file/.../image.png",
"public_html_url": "https://studio.pixelixe.com/storage/file/.../document.html"
}Reopen
Build the next editor URL
function editorUrl({ editorKey, customerDocumentUid, userUid }) {
const params = new URLSearchParams({
apiKey: editorKey,
document_uid: customerDocumentUid,
user_uid: userUid,
overwrite: "true"
});
return "https://studio.pixelixe.com/#api?" + params;
}In production, verify the delivery channel and customer association, validate the payload, and persist it idempotently. Browser-supplied user_uid is metadata, not a replacement for application authentication.
Keep the document lifecycle explicit
These records and checks prevent a successful first export from becoming an incomplete customer journey.
Document lifecycle
Preserve the master
Create customer copies from an approved template. Keep the source UID separate from the saved customer UID so the next user starts from the intended design.
Document lifecycle
Associate the saved result
Store the document UID, document name and output URLs with the customer record resolved by your backend. Reject unexpected associations instead of trusting a posted user identifier.
Document lifecycle
Keep an editable source
Retain a supported editable source if customers need to return. Do not discard it after creating the downloadable image or publishing the final asset.
Document lifecycle
Track the latest output
When the customer edits again, update the application's current document record and downstream image reference. Apply your own deduplication and version policy.
Verify a complete save and reopen cycle
A second editing session is the acceptance test. Run it with an authorized sample customer and a staging delivery endpoint.
Step 1
Open a customer copy
Launch the master template with overwrite=false and an application customer reference. Keep the shared template unchanged.
Step 2
Save through the editor action
The configured completion action sends the documented saved-document payload to your server endpoint.
Step 3
Store the customer document
Validate delivery and ownership, then persist the returned UID and output URLs with your application record.
Step 4
Reopen and edit again
Resolve the saved UID for the authenticated customer and open it with overwrite=true. Confirm a new save updates the expected record.
Reopen editable HTML from your own storage
Use a direct URL to the editable HTML document. The server hosting that document must allow the editor origin to read it.
Remote HTML editor URL
const params = new URLSearchParams({
apiKey: "YOUR_EDITOR_KEY",
graphicUrl: "https://your-app.example/designs/customer-42.html",
graphicName: "Customer campaign",
user_uid: "customer_42"
});
const src = "https://studio.pixelixe.com/#api?" + params;
// Header on the server hosting the editable HTML:
// Access-Control-Allow-Origin: https://studio.pixelixe.comURLSearchParams encodes parameter values. The HTML URL must resolve to the actual document rather than an app login page. Do not expose confidential designs through an unrestricted public endpoint; choose an access arrangement compatible with the editor's fetch behavior.
Debug missing saves and wrong documents
Find the failing lifecycle step before changing template or rendering logic.
| Problem | Likely check | Corrective action |
|---|---|---|
| Every user sees the master again | The app stored only the source template UID. | Persist and reopen the customer document_uid returned after saving. |
| A template changes for another customer | A shared master was opened with overwrite=true. | Use a separate customer copy and authorize document access. |
| The webhook arrives but no record changes | Payload validation, customer association or persistence failed. | Inspect endpoint logs and the validated application record. |
| Remote HTML fails to open | The URL redirects, requires a login or lacks the required CORS header. | Check the actual HTML response and the documented editor origin. |
| Only an image can be reopened | The editable source was discarded. | Retain a saved document UID or supported editable HTML source. |
Document lifecycle references
The example fields and reopening parameters follow the Pixelixe v2 reference checked 20 October 2026. Identifiers and output URLs are illustrative.
Related Pixelixe workflows
Use these connected pages to evaluate the implementation path, adjacent use cases, and Pixelixe product fit.
FAQ
Can a customer edit the same design later?
Yes. Store the saved customer document UID and reopen it with the documented update behavior, or reopen supported editable HTML through graphicUrl.
What is the difference between document_uid and user_uid?
document_uid identifies a design. user_uid is your application's association field returned with the editor output. Neither replaces your own access checks.
Should I set overwrite to true for a master template?
Use overwrite=false when a new customer starts from a shared master. Use overwrite=true only when updating the authorized saved customer document.
Is a PNG enough to continue editing text and layers?
No. A final PNG is a flattened image. Keep the saved editable document or supported editable HTML if the customer must change the original design elements.
What CORS setting does graphicUrl need?
The Pixelixe reference requires the server hosting the editable HTML to allow https://studio.pixelixe.com through Access-Control-Allow-Origin. The URL must return the actual document.
Can I reopen a design generated by the API?
For the documented HTML output path, use the returned HTML document URL with graphicUrl. Check the relevant single-image or bulk contract rather than passing a PNG URL as an editable source.
Validate the second editing session
Start from one template, save one customer copy and reopen it. Use that complete cycle as the foundation for your embedded editing workflow.