Greeting Card Mockups: Front Cover and Inside for Every Design
A folded greeting card prints from a flat outside file with the back cover on the left half and the front cover on the right, so a closed card mockup needs only the right half. Cut each design's front cover from its file, save one card photo with the front panel as its print area, and send one render per design.
Published 9 min readBeck

Key takeaways
- Sent whole, an outside file shrinks onto the card front or gets cut at the fold.
- The front cover is the right half of the file, with the bleed trimmed on three edges.
- An open card takes the inside spread with its bleed trimmed, so a shared inside needs one render.
Which half of the card file is the front
Card printers' own file guides put the front cover on the right half of the outside file for a card that opens like a book, and print on demand cards use the same layout. A closed card in a mockup shows only the right half, plus the edge of the back behind it.
CatPrint's file setup guide (published July 2024, updated July 2025, read 17 November 2026) puts a portrait card's front on the "right side", its back on the "left side" and the inside message on the "right side (of a second file)". 4OVER4's folded card guide (updated September 2026, read 17 November 2026) puts the same rule another way: "On a side-folded card the outside page reads back cover on the left, front cover on the right. Put the front art on the left half and it prints on the back."
Print on demand cards follow it. Printify's 4.25 by 5.5 inch greeting cards, printed by CatPrint, take a 2625 by 1725 pixel file for the outside and another for the inside (Printify's product catalog, read 17 November 2026). That is the flat sheet at 300 DPI with an eighth of an inch of bleed on the outer edges, twice as wide as the closed card.
One outside file, 2,625 by 1,725 pixels: back cover on the left, front cover on the right. Drawn for this test, 17 November 2026.
A card that folds at the top works the same way turned on its side. CatPrint's guide puts the front on the bottom half and the back on the top half, upside down, so the front cover is the bottom half of that file.
What the whole outside file does on a card mockup
A closed card mockup has one panel to fill, so a whole spread cannot fill it. Every placement either shrinks both covers onto the front or cuts the design at the fold.
Left to right: the whole outside file with fit, the whole file with crop, and the front cover alone. Same mockup and area. SudoMock renders, 17 November 2026.
| What goes into the front panel | What the card shows |
|---|---|
The whole outside file, fit | Both covers side by side, small, with blank card above and below |
The whole outside file, crop | The middle of the spread: half the back cover, the fold, and a greeting cut in two |
| The front cover alone | The front design edge to edge, as it prints |
fill stretches the spread into the panel and squeezes every shape to about half its width. The render reference defines the three values; each one places the whole file, so each design's front cover goes in as a file of its own.
Cut the front cover from each file
The front cover is the right half of the outside file with the bleed trimmed from its top, bottom and right edge. The fold edge has no bleed to trim.
For a 2625 by 1725 pixel file at 300 DPI, the bleed is 38 pixels, so the front cover runs from x 1313 to 2587 and from y 38 to 1687: 1274 by 1649 pixels, the 4.25 by 5.5 proportion of the closed card. The same check works for any card product: when the outside file is about twice as wide as the closed card is wide, it is a spread and needs this cut; when its shape matches the closed card, the file is the cover alone and goes in whole.
Save one card photo with the front panel as its print area
A straight-on photo of one blank folded card, saved once as a photo mockup, carries every design in the line. The print area is the front panel, four corner points in the photo's pixels, clockwise from the top left.
Our test photo is a white A2 card standing on a table, 1,280 by 1,600 pixels, with its front panel at 556 by 718 pixels, the same 4.25 by 5.5 shape. A photo from your card supplier or your own shoot works the same way, and so does the Straight-On view of the Greeting Cards template in the library, with the area drawn on its card and the covers cut to that card's shape.
curl -X POST https://api.sudomock.com/api/v1/photo-mockups \-H "x-api-key: $SUDOMOCK_API_KEY" \-H "Content-Type: application/json" \-d '{"source_url": "https://cdn.example.com/photos/blank-a2-card-front.jpg","name": "Folded card, front","print_areas": [{ "points": [[356, 478], [912, 478], [910, 1196], [357, 1196]], "name": "Front cover" }]}'
const response = await fetch('https://api.sudomock.com/api/v1/photo-mockups', {method: 'POST',headers: {'x-api-key': process.env.SUDOMOCK_API_KEY,'Content-Type': 'application/json',},body: JSON.stringify({"source_url": "https://cdn.example.com/photos/blank-a2-card-front.jpg","name": "Folded card, front","print_areas": [{"points": [[356,478],[912,478],[910,1196],[357,1196]],"name": "Front cover"}]}),});const data = await response.json();console.log(data);
import osimport requestsresponse = requests.post("https://api.sudomock.com/api/v1/photo-mockups",headers={"x-api-key": os.environ["SUDOMOCK_API_KEY"],"Content-Type": "application/json",},json={"source_url": "https://cdn.example.com/photos/blank-a2-card-front.jpg","name": "Folded card, front","print_areas": [{"points": [[356,478,],[912,478,],[910,1196,],[357,1196,],],"name": "Front cover",},],},)print(response.json())
package mainimport ("bytes""fmt""io""net/http""os")func main() {payload := []byte(`{"source_url": "https://cdn.example.com/photos/blank-a2-card-front.jpg","name": "Folded card, front","print_areas": [{"points": [[356,478],[912,478],[910,1196],[357,1196]],"name": "Front cover"}]}`)req, err := http.NewRequest("POST", "https://api.sudomock.com/api/v1/photo-mockups", bytes.NewBuffer(payload))if err != nil {panic(err)}req.Header.Set("x-api-key", os.Getenv("SUDOMOCK_API_KEY"))req.Header.Set("Content-Type", "application/json")resp, err := http.DefaultClient.Do(req)if err != nil {panic(err)}defer resp.Body.Close()body, _ := io.ReadAll(resp.Body)fmt.Println(string(body))}
<?php$payload = <<<'JSON'{"source_url": "https://cdn.example.com/photos/blank-a2-card-front.jpg","name": "Folded card, front","print_areas": [{"points": [[356,478],[912,478],[910,1196],[357,1196]],"name": "Front cover"}]}JSON;$ch = curl_init('https://api.sudomock.com/api/v1/photo-mockups');curl_setopt_array($ch, [CURLOPT_CUSTOMREQUEST => 'POST',CURLOPT_RETURNTRANSFER => true,CURLOPT_HTTPHEADER => ['x-api-key: ' . getenv('SUDOMOCK_API_KEY'),'Content-Type: application/json',],CURLOPT_POSTFIELDS => $payload,]);$response = curl_exec($ch);curl_close($ch);echo $response;
Keep two ids from the response: the mockup (data.mockup_id) and its area (data.quads[0].print_area_id). Ours came back with the area exactly as drawn.
Render each design's front cover
A render names the front area and sends the front cover file. The default fit scales the file into the area and keeps its proportions, so a cover cut at the card's shape fills the panel edge to edge.
curl -X POST https://api.sudomock.com/api/v1/photo-mockups/CARD_MOCKUP_ID/render \-H "x-api-key: $SUDOMOCK_API_KEY" \-H "Content-Type: application/json" \-d '{"print_areas": [{"uuid": "FRONT_AREA_ID","artwork_url": "https://cdn.example.com/cards/pines-front-cover.png","placement": { "fit": "fit" }}],"export_options": { "image_format": "jpg", "image_size": 1024 }}'
const response = await fetch('https://api.sudomock.com/api/v1/photo-mockups/CARD_MOCKUP_ID/render', {method: 'POST',headers: {'x-api-key': process.env.SUDOMOCK_API_KEY,'Content-Type': 'application/json',},body: JSON.stringify({"print_areas": [{"uuid": "FRONT_AREA_ID","artwork_url": "https://cdn.example.com/cards/pines-front-cover.png","placement": {"fit": "fit"}}],"export_options": {"image_format": "jpg","image_size": 1024}}),});const data = await response.json();console.log(data);
import osimport requestsresponse = requests.post("https://api.sudomock.com/api/v1/photo-mockups/CARD_MOCKUP_ID/render",headers={"x-api-key": os.environ["SUDOMOCK_API_KEY"],"Content-Type": "application/json",},json={"print_areas": [{"uuid": "FRONT_AREA_ID","artwork_url": "https://cdn.example.com/cards/pines-front-cover.png","placement": {"fit": "fit",},},],"export_options": {"image_format": "jpg","image_size": 1024,},},)print(response.json())
package mainimport ("bytes""fmt""io""net/http""os")func main() {payload := []byte(`{"print_areas": [{"uuid": "FRONT_AREA_ID","artwork_url": "https://cdn.example.com/cards/pines-front-cover.png","placement": {"fit": "fit"}}],"export_options": {"image_format": "jpg","image_size": 1024}}`)req, err := http.NewRequest("POST", "https://api.sudomock.com/api/v1/photo-mockups/CARD_MOCKUP_ID/render", bytes.NewBuffer(payload))if err != nil {panic(err)}req.Header.Set("x-api-key", os.Getenv("SUDOMOCK_API_KEY"))req.Header.Set("Content-Type", "application/json")resp, err := http.DefaultClient.Do(req)if err != nil {panic(err)}defer resp.Body.Close()body, _ := io.ReadAll(resp.Body)fmt.Println(string(body))}
<?php$payload = <<<'JSON'{"print_areas": [{"uuid": "FRONT_AREA_ID","artwork_url": "https://cdn.example.com/cards/pines-front-cover.png","placement": {"fit": "fit"}}],"export_options": {"image_format": "jpg","image_size": 1024}}JSON;$ch = curl_init('https://api.sudomock.com/api/v1/photo-mockups/CARD_MOCKUP_ID/render');curl_setopt_array($ch, [CURLOPT_CUSTOMREQUEST => 'POST',CURLOPT_RETURNTRANSFER => true,CURLOPT_HTTPHEADER => ['x-api-key: ' . getenv('SUDOMOCK_API_KEY'),'Content-Type: application/json',],CURLOPT_POSTFIELDS => $payload,]);$response = curl_exec($ch);curl_close($ch);echo $response;
data.print_files[0].export_path in the response is the URL of the rendered card. The average SudoMock render finishes in under a second. Four designs of one holiday line went through the same mockup and area:
![]() | ![]() |
![]() | ![]() |
All four are SudoMock renders from one card photo, 17 November 2026. The card photo was generated for this test; the designs and the shop mark on their back covers were drawn for it.
Show the inside on an open card
The inside file goes on a photo of the open card whole, with its bleed trimmed on all four edges, because both inside panels face the camera at once. Save the open card as a second photo mockup with one print area around the two inside panels, then render each design's inside file into it.
The inside file with its bleed trimmed, 2,549 by 1,649 pixels, on an open card, message on the right inside panel. SudoMock render, 17 November 2026.
The message sits on the right inside panel, where CatPrint's guide puts it, and the left panel stays clear for a handwritten note. Cards that share one inside file need this render only once.
Render a whole card line
One saved closed card and one saved open card carry the whole line: each CSV row names a design's outside file and, when it has one, its inside file. The script cuts each front cover and trims each inside file in memory, then sends them in the render's base64 field, so no second file is stored anywhere.
sku,outside_png,inside_pngXM-PINES-01,https://cdn.example.com/cards/pines-outside.png,https://cdn.example.com/cards/inside-season.pngXM-WREATH-02,https://cdn.example.com/cards/wreath-outside.png,
Install the two libraries it uses (pip install requests pillow), paste the two mockup ids and their area ids, export your key as SUDOMOCK_API_KEY and start the script with the CSV path as its only argument. BLEED is 38 pixels for an eighth of an inch at 300 DPI; set it to your printer's bleed. For a card that folds at the top, the cover is the bottom half: crop (BLEED, (h + 1) // 2, w - BLEED, h - BLEED).
import base64, csv, io, os, sys, timefrom concurrent.futures import ThreadPoolExecutorimport requestsfrom PIL import ImageFRONT = {"mockup": "CARD_MOCKUP_ID", "area": "FRONT_AREA_ID"}INSIDE = {"mockup": "OPEN_CARD_MOCKUP_ID", "area": "INSIDE_AREA_ID"}BLEED = 38HEADERS = {"x-api-key": os.environ["SUDOMOCK_API_KEY"]}def load(url):return Image.open(io.BytesIO(requests.get(url, timeout=60).content)).convert("RGB")def encoded(image):buf = io.BytesIO()image.save(buf, "PNG")return base64.b64encode(buf.getvalue()).decode()def front_cover(url):file = load(url)w, h = file.sizereturn encoded(file.crop(((w + 1) // 2, BLEED, w - BLEED, h - BLEED)))def inside(url):file = load(url)w, h = file.sizereturn encoded(file.crop((BLEED, BLEED, w - BLEED, h - BLEED)))def render(target, artwork, name):entry = {"uuid": target["area"], "placement": {"fit": "fit"}, **artwork}body = {"print_areas": [entry], "export_options": {"image_format": "jpg", "image_size": 1024}}url = f"https://api.sudomock.com/api/v1/photo-mockups/{target['mockup']}/render"res = requests.post(url, json=body, headers=HEADERS, timeout=120)if res.status_code == 429:time.sleep(int(res.headers.get("Retry-After", 5)))res = requests.post(url, json=body, headers=HEADERS, timeout=120)if not res.ok:return f"{name} failed {res.status_code} {res.text}"image = requests.get(res.json()["data"]["print_files"][0]["export_path"], timeout=60)if not image.ok:return f"{name} download failed {image.status_code}"with open(name, "wb") as f:f.write(image.content)return f"{name} saved"def card(row):lines = [render(FRONT, {"base64": front_cover(row["outside_png"])}, f"{row['sku']}-front.jpg")]if row.get("inside_png"):lines.append(render(INSIDE, {"base64": inside(row["inside_png"])}, f"{row['sku']}-inside.jpg"))return "\n".join(lines)with open(sys.argv[1], newline="") as f:rows = list(csv.DictReader(f))with ThreadPoolExecutor(max_workers=8) as pool:for lines in pool.map(card, rows):print(lines)
The two rows above come out as three images: XM-PINES-01-front.jpg, XM-PINES-01-inside.jpg and XM-WREATH-02-front.jpg. Past a few hundred cards, switch each request to "is_async": true and pick the images up from their jobs. A shop that keeps its line in a spreadsheet can run the same rows from a Make scenario on Google Sheets without code, with the front covers exported once from the design tool.
A card PSD of your own
A card PSD with a smart object on the front panel takes the same front cover file, one render request per design, once it is uploaded with POST /api/v1/psd/upload (upload a PSD). In the dashboard, PSD uploads are capped at 300 MB, and API uploads support files up to Adobe's official PSD file size limit.
Next step
Cut the front cover from one design's outside file, save a straight-on card photo with its front panel as the print area, and render that design and one more. With the two ids in FRONT, the script covers the rest of the line, and the open card adds the inside. The Greeting Cards template has Straight-On, Three-Quarter, From Above and lifestyle views, and GET /api/v1/library/templates?search=greeting%20card returns the source_url of each for the same create call (start from a ready-made template); the holiday and greeting card templates include flat Holiday Cards printed on one side or two. Every target and placement field is in the render reference. Holiday products beyond cards follow the same one-request-per-design pattern in ornament mockups, and garments with a file per side in hoodie mockups.
Frequently asked questions
Which side of a greeting card file is the front?
On a card that opens like a book, the front cover is the right half of the outside file and the back cover is the left half. On a card that folds at the top, the front is the bottom half and the back sits upside down in the top half. The inside goes in a second file of the same size.
What size is a greeting card print file?
The flat sheet plus bleed, about twice as wide as the closed card. Printify's 4.25 by 5.5 inch cards take a 2625 by 1725 pixel outside file and an inside file of the same size, which is 8.75 by 5.75 inches at 300 DPI. A closed card mockup shows the right half of the outside file, 1274 by 1649 pixels once the bleed is trimmed.
Can I put my whole card file into a card mockup?
Only on a mockup that shows the whole sheet, such as an open card for the inside file with its bleed trimmed. A closed card shows one panel, so the whole outside file either shrinks with both covers side by side or gets cut at the fold. Cut the front cover out and send that file.
Can I make mockups for all my card designs at once?
Yes. Save one card photo as a photo mockup with the front panel as its print area, then send one render per design with that design's front cover. A script over a CSV of designs renders the whole line, and a second saved photo of the open card adds the inside.
Sources
- Setting Up Your Greeting Card Files for Printing (opens in new tab), CatPrint
- Folded Card Printing Sizes, Fold Direction and Template Setup (opens in new tab), 4OVER4
- Create a mockup from a product photo (opens in new tab), SudoMock docs
- Render a photo mockup (opens in new tab), SudoMock docs
- Render artwork onto a photo mockup (opens in new tab), SudoMock docs
- Start From a Ready-Made Template: No File of Your Own (opens in new tab), SudoMock docs
- Upload a PSD (opens in new tab), SudoMock docs
Beck
CTO
Related articles

Print on Demand Ornaments: A Mockup for Every Holiday Design
One ceramic ornament photo, a round PNG per design and one render request each, with real renders of a cardinal, a gingerbread cottage and a snowflake.
6 min read

Wall Calendar Mockups for 2027: Cover, Every Month and Back
Save an open and a closed calendar photo as photo mockups and render the cover, all twelve months and the back of every 2027 design.
9 min read

Etsy Bulk Listing: Draft a Whole Drop With a Mockup per Color
Put a whole holiday drop on Etsy as drafts, with one mockup per color rendered from your own template and linked to its color option.
8 min read
Explore by use case
See SudoMock in action for your specific product category
Your own PSD, rendered via API
Render your own PSD through the API. Start with 500 one-time credits, no card.



