Peecho integration: embed a design editor with Polotno

Embed the Polotno design editor in your app so users can create print-ready PDFs, then send them to Peecho for printing and global fulfillment.

Polotno + Peecho pairs Polotno's embedded design editor SDK with Peecho's Print API v3. Your users create print-ready PDFs inside your app, your backend hands them to Peecho, and Peecho prints and ships globally.

The problem Peecho doesn't solve

Peecho's API assumes you already have a valid, print-ready PDF. Producing that file is the hard part — especially when the design depends on user input, uploaded media, structured data, or AI-generated content.

Without a proper creation layer, teams end up with one of four weak setups:

Sending users to external design tools, breaking the product flow
Rigid form-to-PDF pipelines that can't handle real layout control
Backend-only PDF assembly that is brittle and hard to iterate on
Custom in-house editors that take months to build and never stop costing

Polotno is the piece that goes in front of Peecho so your users design the product inside your app, and your backend always hands Peecho a clean, spec-compliant file. See how Peleman automated their web-to-print workflow with the same pattern.

How the integration works

Design — User opens a template in the embedded Polotno editor inside your app. The template can be pre-populated from structured data, user uploads, or AI-generated assets.
Edit — User personalizes text, images, layout, and variable fields. Your product controls what is editable and what is locked.
Export — Your app calls Polotno's PDF export (with bleed and crop marks) and uploads the file to a URL Peecho can fetch. For PDF/X-1a with CMYK, run the @polotno/pdf-export package server-side.
Order — Your backend creates the order on Peecho's Print API v3, referencing the PDF URL plus product and shipping details.
Fulfill — Peecho prints and ships. Your backend receives status updates via Peecho webhooks and surfaces them in your product.

Polotno owns the creation experience. Peecho owns production and logistics. Your backend is the thin orchestration layer in between.

What a request looks like

// 1. Client-side: export a PDF with bleed + crop marks.
const pdfDataUrl = await store.toPDFDataURL({
  pixelRatio: 2,
  includeBleed: true,
  cropMarksEnabled: true,
})
// For PDF/X-1a + CMYK, export on the server with @polotno/pdf-export:
//   await jsonToPDF(store.toJSON(), './print.pdf', { pdfx1a: true })
const contentUrl = await uploadToYourStorage(pdfDataUrl)

// 2. Create the order on Peecho (Print API v3).
//    Test env: https://test.www.peecho.com/rest/v3/order/
await fetch("https://www.peecho.com/rest/v3/order/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    merchant_api_key: PEECHO_API_KEY,
    currency: "EUR",
    item_details: [{
      item_reference: "order-1234",
      offering_id: PEECHO_OFFERING_ID,
      quantity: 1,
      file_details: {
        content_url: contentUrl,
        content_width: 210,
        content_height: 297,
        number_of_pages: 40,
      },
    }],
    address_details: {
      email_address: customer.email,
      shipping_address: shippingAddress,
    },
  }),
})
// 3. Submit payment, then Peecho prints, ships, and posts status
//    updates to your webhook.

// 1. Client-side: export a PDF with bleed + crop marks.
const pdfDataUrl = await store.toPDFDataURL({
  pixelRatio: 2,
  includeBleed: true,
  cropMarksEnabled: true,
})
// For PDF/X-1a + CMYK, export on the server with @polotno/pdf-export:
//   await jsonToPDF(store.toJSON(), './print.pdf', { pdfx1a: true })
const contentUrl = await uploadToYourStorage(pdfDataUrl)

// 2. Create the order on Peecho (Print API v3).
//    Test env: https://test.www.peecho.com/rest/v3/order/
await fetch("https://www.peecho.com/rest/v3/order/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    merchant_api_key: PEECHO_API_KEY,
    currency: "EUR",
    item_details: [{
      item_reference: "order-1234",
      offering_id: PEECHO_OFFERING_ID,
      quantity: 1,
      file_details: {
        content_url: contentUrl,
        content_width: 210,
        content_height: 297,
        number_of_pages: 40,
      },
    }],
    address_details: {
      email_address: customer.email,
      shipping_address: shippingAddress,
    },
  }),
})
// 3. Submit payment, then Peecho prints, ships, and posts status
//    updates to your webhook.

// 1. Client-side: export a PDF with bleed + crop marks.
const pdfDataUrl = await store.toPDFDataURL({
  pixelRatio: 2,
  includeBleed: true,
  cropMarksEnabled: true,
})
// For PDF/X-1a + CMYK, export on the server with @polotno/pdf-export:
//   await jsonToPDF(store.toJSON(), './print.pdf', { pdfx1a: true })
const contentUrl = await uploadToYourStorage(pdfDataUrl)

// 2. Create the order on Peecho (Print API v3).
//    Test env: https://test.www.peecho.com/rest/v3/order/
await fetch("https://www.peecho.com/rest/v3/order/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    merchant_api_key: PEECHO_API_KEY,
    currency: "EUR",
    item_details: [{
      item_reference: "order-1234",
      offering_id: PEECHO_OFFERING_ID,
      quantity: 1,
      file_details: {
        content_url: contentUrl,
        content_width: 210,
        content_height: 297,
        number_of_pages: 40,
      },
    }],
    address_details: {
      email_address: customer.email,
      shipping_address: shippingAddress,
    },
  }),
})
// 3. Submit payment, then Peecho prints, ships, and posts status
//    updates to your webhook.

// 1. Client-side: export a PDF with bleed + crop marks.
const pdfDataUrl = await store.toPDFDataURL({
  pixelRatio: 2,
  includeBleed: true,
  cropMarksEnabled: true,
})
// For PDF/X-1a + CMYK, export on the server with @polotno/pdf-export:
//   await jsonToPDF(store.toJSON(), './print.pdf', { pdfx1a: true })
const contentUrl = await uploadToYourStorage(pdfDataUrl)

// 2. Create the order on Peecho (Print API v3).
//    Test env: https://test.www.peecho.com/rest/v3/order/
await fetch("https://www.peecho.com/rest/v3/order/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    merchant_api_key: PEECHO_API_KEY,
    currency: "EUR",
    item_details: [{
      item_reference: "order-1234",
      offering_id: PEECHO_OFFERING_ID,
      quantity: 1,
      file_details: {
        content_url: contentUrl,
        content_width: 210,
        content_height: 297,
        number_of_pages: 40,
      },
    }],
    address_details: {
      email_address: customer.email,
      shipping_address: shippingAddress,
    },
  }),
})
// 3. Submit payment, then Peecho prints, ships, and posts status
//    updates to your webhook.

What Polotno handles vs. what Peecho handles

Polotno (in your app)

Embedded editor UI with templates and editable regions
Variable data / VDP driven by backend data or AI
Brand locking, layout rules, typography
Print-ready PDF export with bleed + crop marks (client-side) or PDF/X-1a CMYK (server-side)
Client, self-hosted, or cloud rendering depending on throughput

Peecho (backend)

Full product catalog — books, magazines, wall art, stationery
Printing, binding, finishing
Global fulfillment
Order status webhooks

Technical details

Export format: PDF with bleed + crop marks from store.toPDFDataURL; PDF/X-1a with CMYK via the @polotno/pdf-export server-side package.
Variable data: Templates driven by structured data or AI to generate many personalized designs from one template — see dynamic template variables.
Multi-page products: Books and magazines preserve page order and spreads on export.
Rendering modes: Client-side, self-hosted (via polotno-node), or Polotno Cloud Render API.
Handoff to Peecho: POST the order payload (offering_id, file_details, address_details) to Peecho's Print API v3, then listen for webhooks.

What you can build

Any product in Peecho's catalog that accepts a PDF:

Books — hardcover, softcover, layflat
Magazines — glossy or matte cover
Wall art — art prints, gallery prints, framed prints, canvases, aluminium dibonds
Business stationery — cards, brochures, calendars, flyers, postcards, posters, stickers, notebooks, letterheads, envelopes, presentation folders, roll-up banners

FAQ

Do I need an existing Peecho account?

Yes. Peecho handles the fulfillment contract, product catalog, and shipping — you configure products and pricing on their side.

What file format does Polotno export?

PDF with bleed + crop marks (client-side) or PDF/X-1a with CMYK (server-side via @polotno/pdf-export).

Can I use variable data printing (VDP)?

Yes. Templates can be driven programmatically from structured data — see Polotno's VDP docs.

Where does the editor run — client, server, or cloud?

All three are supported. Compare rendering modes.

Is this self-serve yet?

Not during the closed beta. Self-serve onboarding comes after GA.

Closed beta

The Polotno + Peecho integration has been in closed beta since April 2026. If you're building on Peecho and need a real in-app creation layer, request access — or start integrating Polotno first and we'll pair you with Peecho when the beta opens up.

Polotno

My account

Log out

Try the editor

Start integrating

Polotno