Picture of Use the Multipart Editor fully inside embedded editors (via iFrame)

Use the Multipart Editor fully inside embedded editors (via iFrame)

If you already embed the Infigo editor into your own portal or application using an iFrame, this update gives you a big new option:

You can now use the Multipart Editor in exactly the same way you’ve been using MegaEdit.

That means external apps (portals, CRMs, custom frontends, etc.) can drive multipart products end-to-end inside an embedded editor:

  • Open a multipart product directly in an iFrame

  • Let users upload files and configure all parts inside your own UI

  • Capture “add to basket” and other events via postMessage

  • Use the same order APIs (RecordOrder, PlaceOrder) you already use for MegaEdit

No special workaround, no separate integration path. Multipart now behaves like a first-class citizen in the iFrame flow.

What’s actually new

Previously, the iFrame editor flow was focused on MegaEdit products. Multipart products generally had to be used via the standard storefront flow.

This release adds three main pieces:

  1. Multipart support in the iFrame link endpoint
    The /editor-linkfor/get endpoint can now generate embed links for multipart products, not just MegaEdit.
    From a calling application’s point of view, you request a link for a multipart product and embed it in an iFrame in the same way you do for MegaEdit.

  2. Multipart emits the same iFrame events as MegaEdit
    The Multipart Editor now sends the same postMessage events as MegaEdit:

    • EditorLoaded – when the editor is ready

    • Infigo.ItemAddedToBasket – when the user adds the configured item to the basket

    • ExternalDataUpdate – when external data synced to the editor is updated
      Your existing event handling code can be reused for multipart, instead of writing a separate handler.

  3. Multipart flows use the same order endpoints
    Jobs created from Multipart inside an iFrame now flow through the same backend endpoints as MegaEdit:

    • RecordOrder

    • PlaceOrder
      Any existing logic you have around those endpoints (creating orders, mapping references, updating external systems) can now work with multipart products too.

The public iFrame demo app on GitHub has also been updated to show how to embed multipart products using the same patterns.

When you’d use this

This is useful if you:

  • Run a custom front end (e.g. portal, PIM, MIS UI, corporate intranet) and want users to design or upload multipart jobs without ever seeing the standard Infigo storefront.

  • Need to control the user journey completely, but still want to use Infigo Multipart Editor for all the heavy lifting.

  • Already integrated MegaEdit via iFrame and want to extend that flow to multipart products with minimal extra work.

Typical examples:

  • A customer portal where users upload multi-page artwork sets (e.g. multiple labels, panels, or sides) in one session.

  • An MIS or quoting system that launches the editor from within its own UI and collects the result as part of an internal workflow.

How it works (high level)

From your application’s side, the flow looks like this:

  1. Generate an editor link
    Your app calls the /editor-linkfor/get endpoint, but this time you pass the product that is configured as a Multipart product in Infigo.
    The endpoint returns a URL that can be embedded inside an iFrame.

  2. Embed in an iFrame
    You render that URL inside an iFrame in your application (e.g. on a “Customise artwork” page).
    All the usual requirements still apply: HTTPS, matching domains/cookies for authentication, etc.

  3. User configures the multipart job
    Inside the iFrame, the user can:

    • Upload artwork files for each part

    • Configure options (stock, size, versions, etc., depending on your setup)

    • Save and/or add the multipart job to the basket

    They stay completely inside your UI shell while the editor runs inside the iFrame.

  4. Listen for events
    Your page listens for postMessage events from the iFrame. For multipart, you can rely on the same events you may already use for MegaEdit:

    • EditorLoaded lets you know when to show or enable surrounding UI.

    • Infigo.ItemAddedToBasket tells you that the job is ready and has been added.

    • ExternalDataUpdate allows you to sync external values back and forth if you’re using that pattern.

  5. Place the order via API
    Once the item is in the basket, your backend can call RecordOrder and PlaceOrder just like you do for MegaEdit flows.
    Multipart orders go through the same pipeline, so you don’t need a separate set of order endpoints.

Things to double-check when you start using this

When you first enable multipart via iFrame, it’s worth walking through a few checks:

  • Use a multipart product and confirm it opens correctly inside your iFrame (no authentication errors, cookies behave, etc.).

  • Make sure the editor loads fully and your code receives the EditorLoaded event.

  • Complete a multipart configuration and confirm that Infigo.ItemAddedToBasket is received as expected.

  • Call your usual order APIs and make sure:

    • The order is created successfully

    • The multipart files and job details appear correctly in Infigo

  • Also verify traditional multipart flows still work:

    • A “normal” multipart product from the storefront

    • Multipart with versions

    • Edit from Saved Product Options (SPO)

    • Editor from Approval Workflow

Once those are all behaving, you can treat multipart and MegaEdit products the same way in your embedded editor integrations – just point the iFrame at the right product and reuse your existing event and order logic.

Incomplete