Polotno + MakePlayingCards (MPC) pairs Polotno's embedded design editor SDK with MPC's XML API. Your users design card decks — poker, tarot, trading card games, or board-game components — inside your app, and your backend submits the deck to MPC for printing and global fulfillment.
The problem MPC doesn't solve
MPC is the de-facto printer for indie game designers, but designing a deck today means placing every card by hand in InDesign or Affinity. A 250-card TCG set is weeks of manual work before you can even test a print. MPC's XML API handles production perfectly — it just takes finished, per-card print files.
Designers and platforms without a card editor usually:
- Lay out each card manually in InDesign, then export one-by-one
- Write custom scripts to stitch a CSV into card artwork
- Skip per-card variation entirely because the design work is prohibitive
Polotno goes in front of MPC with a template + data workflow: design one card template, bind it to structured data, and generate the full deck programmatically using dynamic template variables.
How the integration works
- Design — Designer creates a card template in Polotno: art slot, name field, stats, abilities, rarity indicator, frame overlays.
- Bind data — Your app maps template fields to rows in a CSV or database using Polotno's variable templates. Each row = one card.
- Render — Polotno Cloud Render API renders every card as a print-ready PDF (or PNG) at 300dpi with bleed per MPC's specs.
- Order — Your backend submits the deck to MPC's XML API with the per-card files, card stock, finish, and box type.
- Fulfill — MPC prints, collates, boxes, and ships.
What a request looks like
// 1. Render the deck from one template + a data source.
// Each row in the CSV produces one card via dynamic template variables.
const cards = await renderDeckFromCsv({
templateJson, // Polotno JSON with variable placeholders
csvRows, // array of card data rows
bleedPx: 36, // ~3mm at 300dpi
dpi: 300,
})
// cards[i] = { front: frontFileUrl, back: backFileUrl }
// 2. Submit to MPC's XML API.
// See https://www.makeplayingcards.com/help/api.html for the full schema.
await fetch(MPC_XML_ENDPOINT, {
method: "POST",
headers: { "Content-Type": "application/xml" },
body: buildMpcXml({
cards,
productType: "poker",
cardStock: "S30",
finish: "linen",
quantity: 1,
}),
})
What Polotno handles vs. what MPC handles
Polotno (in your app)
- Embedded card-template editor
- Dynamic fields bound to CSV or database rows
- Brand locking (stat bars, frames, rarity indicators)
- Per-card front + back templates
- Batch render of full decks with bleed and safe zone
- Print-ready PDF or 300dpi PNG per MPC spec
MPC (backend)
- Full card format catalog (poker, bridge, tarot, jumbo, custom)
- Printing across card stocks and finishes
- Collation and box packaging
- Sandbox + production environments
- Global fulfillment
Technical details
- Export: PDF or PNG at 300dpi, MPC's bleed and trim per card type.
- Formats: poker, bridge, tarot, jumbo, custom sizes.
- Batch: One template + N data rows renders N cards via the Cloud Render API.
- Variable data: Every card field can be bound to a row — per-card art, names, stats, rarity. See VDP docs.
- Rendering modes: Client-side for small decks; Cloud Render API for 200+ cards.
What you can build
Any MPC product that accepts per-card files:
- Trading card games (TCGs)
- Playing card decks — poker, bridge, tarot
- Board-game card components
- Kickstarter deck campaigns
- Education flashcards
- Prototype cards for playtesting
FAQ
Do I need an MPC account?
Yes. You'll need API credentials for both sandbox and production environments.
Can I bind cards to a CSV or database?
Yes — that's the core workflow. Design one template, bind fields to rows using dynamic template variables, render the whole deck in one pass.
How are card fronts and backs handled?
Polotno supports per-card front and back templates. The backend submits both per MPC's XML schema.
Is this ready for Kickstarter-scale decks?
Yes. For 200+ card sets, use the Cloud Render API for throughput.
Is this self-serve yet?
Not during the closed beta.
Closed beta
The Polotno + MPC integration has been in closed beta since April 2026. If you're building on MPC and need a batch card-template editor, request access — or start integrating Polotno first.
