Orshot Ad Creative: one template, every ad size, every variant

An ad campaign is one design repeated many times: three Meta sizes, five display sizes, four headline tests, a new price every week. Drawing each one is slow, and image models cannot be trusted with prices, logos or the word "40%". So this skill builds an ad template once and renders it with Orshot, an API for automated image, PDF and video generation from templates. The price is real text, the logo is the real logo, and the 300th ad matches the first.

Writing ad copy is your job. Rendering it into pixel-exact ads in every size is Orshot's.

The layouts come from the ad formats orshot_plan_design returns for the job: the formats advertisers actually run, built from 60 static ads that were live in October 2026, most of them running 30 days or longer: 40 from the Meta Ad Library (picked from the ad pages of 23 direct-to-consumer brands and about 230 SaaS, B2B and local service ads), 11 from the LinkedIn Ad Library (240 cards from 10 B2B advertisers) and 9 from the Google Ads Transparency Center (about 4,000 creatives searched). Plan before you design.

What people ask for

• "Our Meta statics are fatiguing after a week. Make 10 new variations of our winning ad. Only the hook changes." (Refresh before the ad fatigues.)
• "Here's a product photo of the Tidewell bottle. Give me 15 static ad variations to test, feed and story sizes." (Product photo on a busy background, then Variants.)
• "I already make product scenes with an AI image model. Put our headline, price and logo on top so the text is never wrong."
• "Make catalog ads for every product in this Shopify store, with the sale price struck through when there is one." (Catalog and feed ads.)
• "I run Meta ads for six HVAC and roofing clients. Set up one ad template per client so I can push a new offer every week." (Agencies.)
• "Our recruiters at Hirebright send job details every day. Turn each one into a static job ad from our approved template in n8n."

Where the facts live

This skill is the flow. Field shapes, allowed values and limits are in the docs. Read the page instead of guessing.

• Smart Resize over the API (size, extraSizes, preset list with sizes, response shape, limits): https://orshot.com/docs/api-reference/render-from-studio-template.md
• Smart Resize in the editor (adjust and save a size): https://orshot.com/docs/orshot-studio/smart-resize.md
• Style overrides per render (for example opacity): https://orshot.com/docs/orshot-studio/style-parameters.md
• Canvas background per render: https://orshot.com/docs/orshot-studio/api-specs.md
• Template JSON: orshot_get_design_spec topic template-json, or https://orshot.com/docs/definitions/template-json.md
• Credits: https://orshot.com/docs/definitions/credits-usage.md
• Shopify app: https://orshot.com/docs/integrations/shopify.md
• Animated output (videoOptions): https://orshot.com/docs/video-generation/video-options.md
• Ad formats by type (skeleton, sizes, fields): orshot_plan_design with the campaign as job; every format by name: orshot_get_design_spec topic formats-catalogue
• Default size sets per campaign: references/ad-sizes.md
• Design craft (hierarchy, type, color, safe areas): load the orshot-design skill.

Setup

1. Connect the hosted MCP server https://mcp.orshot.com/full (OAuth in the browser, no key). Client steps: https://orshot.com/docs/integrations/mcp-server.md. Scheduled jobs, n8n, Make, Zapier and server code use REST with ORSHOT_API_KEY (Workspace Settings > API Keys).
2. Confirm with orshot_get_account. A "plan limit" or "inactive subscription" reply is billing, not auth: send the user to https://orshot.com/pricing.
3. Get the brand: orshot_get_brand_kit. Empty and the user has a website? orshot_scan_brand_website with the URL, show what it found, and only after a yes call orshot_import_brand_website.

The idea: one design, every size

Design the ad once at its main size. Render it with extraSizes and Smart Resize re-lays the same design out for each extra size in the same call. size replaces the main size; extraSizes adds copies. A value is a preset slug, a "WIDTHxHEIGHT" string or { width, height }. Presets and limits: Smart Resize. Default sets for Meta, display and LinkedIn: references/ad-sizes.md.

Rules that keep Smart Resize honest:

• Pick the main size from the format, then from where most spend goes. The format from orshot_plan_design names its size (catalog frames, local offers and LinkedIn are 1:1). Otherwise Meta-first campaigns design at 1080x1350, display-first at 300x250 or 1200x1200.
• Strip banners (728x90, 320x50, 970x250) have room for a logo, a 3 to 5 word headline and a CTA. Look at them before shipping. If one does not read, build a separate strip template with the same parameter ids. (A person can also fix that size in the Studio's Smart Resize panel with Adjust Variant; an agent cannot, so offer it to the user rather than relying on it.)
• extraSizes works for image formats only. Each extra size is billed as its own image.

Ad anatomy and copy rules

An offer ad has these parts; make each one it uses a dynamic field. Formats without a product or price (a lead magnet, a quote, a stat card) use their own fields from the formats file plus the shared ids below:

One field set for every layout. Templates in one campaign, and every client template an agency keeps, use the same ids, so one row renders through all of them: brand_name, logo, kicker (the line above the price), headline, old_price, price, offer (the gift or bonus, often a sticker), product_image (a product), photo (a scene: a job site, a van, a portrait), phone, cta, legal. The formats file lists only the extra fields a format adds. Catalog templates for Shopify use the app's field names from its docs instead.

Copy rules:

• Few words on the image. The ad's primary text and headline fields carry the long copy; the image carries the hook, the offer and the product. About 20 words on the image is a hard ceiling; 8 to 12 is better.
• One message per ad. A test changes one thing at a time.
• Numbers are digits: "40%", "$29", "3 days left".
• The hook goes in the top third and reads on its own, so it is the first thing seen. In Stories and Reels the bottom of the frame sits under the caption and buttons.
• Story placements: keep text, offer and logo out of the zones the platform UI covers: on a 9:16 ad the top 13 to 20% and the bottom 20% hold no text. The safe areas are in orshot_get_design_spec topic social-pack, section 1.
• Specific numbers beat adjectives: "$2.65 per meal", "2g vs 39g of sugar". The offer sits on the product (a sticker, the price under the kicker), never in a footer.
• Contrast: white text on a photo needs a dark scrim (a gradient shape) under it.

Build the template once

1. orshot_list_studio_templates with search ad. A good one exists? Read its keys with orshot_get_studio_template_modifications and skip to rendering.
2. Plan, and pick the format. orshot_plan_design with the brief, job (the user's words: "meta ad for the spring sale"), the main size and on_brand: true for brand work. It returns the ad formats advertisers run for that job (skeleton, size, fields, what makes each work) and the plan: palette, fonts, type scale. Pick the format whose fields match what changes per ad and say it in one line before you design: "DTC offer ad, offer as the headline: kicker, struck old price and new price, the open box filling the middle, a free-gift sticker on it." The format sets the skeleton, the sizes of things and the fields; the brand's colours win over the plan's accent.
3. Read orshot_get_design_spec topic template-json once per session, and load the orshot-design skill if the user has not fixed a look.
4. Find real imagery: the user's product shots from the brand kit, or orshot_search_stock_media with the subject in 1 to 3 words. Pick stock with no visible brand or label (many product shots show a real logo), and tell the user it is a placeholder for their own shot. Resolve a stock pick to a URL with orshot_use_stock_media, or put its ref straight into the template.
5. orshot_create_template_design named Ad: <brand> <campaign type>, canvas_width and canvas_height from the format's size, tags: ["ad"], includeThumbnails: true. Every part in the table above is parameterizable: true with its parameterId. Text layers get textMode: "fit" and a minFontSize. A seasonal background colour needs no field: send canvasBackgroundColor per render.
6. Read the thumbnail and the design checks. Fix real problems with one orshot_update_template_design call; small edits go through orshot_patch_template_elements.
7. Render once with all target sizes in extraSizes and look at every variant, the strips most of all, before any campaign run.

A campaign is a set of layouts

Winning advertisers run one offer or one quote in 3 to 6 layouts at once and keep the ones that hold. Build 2 to 4 templates for a campaign from different formats in the formats file (offer as the headline, proof chips, a native screenshot, a review card), all with the same parameter ids, and render the same row through each. A layout test is then one batch, and the next week's offer fills every layout at once.

For Stories and Reels, brands ship a native 9:16 sibling of each static, not a stretched feed ad. Render the 9:16 with Smart Resize and look at it. A result with resize.mode: "block" or a coverage under about 0.6 is the square letterboxed in empty ground: build the sibling. If any text sits in the top 250 px or the bottom 380 px of the 1920, the product shrinks, a band of empty ground appears or a sticker stretches, build the sibling: a second template at 1080x1920 named <feed name> 9:16, with the same parameter ids and an extra story tag, its text between y 270 and 1530. That is the agent's path; render the same row through both.

Product photo on a busy background

Cut it out first: orshot_render_library_template with templateId: "image-background-removal-api", modifications: { "inputImage": "<photo URL>" } and format: "png". Check the fields with orshot_get_library_template_modifications if unsure. Use the result as product_image with objectFit: "contain". It costs 1 AI credit per image, a separate pool from render credits (Credits). Over REST it is POST https://api.orshot.com/v1/generate/images with the same templateId and modifications (Render from a utility template).

Already making images with an AI model? Keep them, fix the text

Image models get prices, offers and small words wrong. Keep the user's generated image and send it as product_image, or as a full-bleed background image field. The template sets the headline, offer, price, CTA and logo as real text. The image URL must be public and must not expire (Gotchas).

Rebuild a winning layout with the user's own assets

Start from the user's own past winner, or a screenshot of a layout they like. Note where the hook, product, offer and logo sit, and build that structure with the user's brand kit, product photos and words. Never copy another brand's logo, product shots, claims or copy, and do not scrape ad libraries for material.

Agencies: one template per client

Each client gets its own template, tagged with the client name (tags: ["ad", "<client>"]), and every client template uses the same parameterIds. One automation then serves every client: it switches templateId and sends that client's row. Find a client's template with orshot_list_studio_templates and its tag.

Render per campaign

Over MCP, orshot_render_template takes templateId, modifications, format, size, extraSizes and fileName as top-level arguments. Over REST the size fields go inside response:

curl -s -X POST https://api.orshot.com/v1/studio/render \
  -H "Authorization: Bearer $ORSHOT_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "templateId": 123,
    "modifications": {
      "headline": "Sleep cooler tonight",
      "offer": "40% OFF",
      "price": "$89",
      "old_price": "$149",
      "cta": "Shop the sale",
      "product_image": "https://cdn.example.com/pillow.png",
      "cta.opacity": "0"
    },
    "response": {
      "type": "url", "format": "png",
      "fileName": "bf26_offer-40_v1_feed",
      "extraSizes": { "square": "instagram-post", "story": "instagram-story", "mrec": "medium-rectangle-ad" }
    }
  }'

data.content is the main ad. Each entry in data.extraSizes carries its own link in content. An entry with an error failed alone; the others are fine. Show the user every link.

The CTA is hidden for Meta in the example. For a display-only run, leave cta visible.

Variants for testing

Test one variable at a time: headline angle, offer, or image. Write 3 to 5 options of that one field and keep the rest fixed.

• orshot_batch_render_template takes the templateId, a renders array of modification sets, and one shared format, size and extraSizes. Results come back in the same order as renders. Split large sets into several calls; the tool schema gives the per-call cap. Over REST, loop POST /v1/studio/render.
• Naming: <campaign>_<variable>-<value>_v<n>_<size>, for example bf26_headline-sleep-cooler_v2_story. Batch renders take no fileName, so keep a table of index, name, copy and URL, and hand it to the user with the links. Single renders take fileName.
• Cost before you send: variants x (1 + extra sizes). 5 headlines with 3 extra sizes is 20 images, 20 credits.
• After the test, make the winner's copy the template default with orshot_patch_template_elements, so future runs start from it.

Refresh before the ad fatigues

Static ads wear out, so plan new variants on a schedule instead of waiting for results to drop.

• A sheet with one row per concept: the winning image, the offer and price, and a column of new hooks.
• Once a week, render the new hooks for each concept. Only the hook changes (or only the image). Name each file with the pattern above and write each URL back to its row.
• Run it where the user already automates (n8n, Make, Zapier or code), or as an Orshot Workflow draft (see Sheets, CSV and Airtable feeds below).
• Say the weekly cost first: hooks x (1 + extra sizes) credits per concept. 8 hooks with 2 extra sizes is 24 credits per concept a week.
• When a test ends, patch the winning hook into the template default as above.

Catalog and feed ads: one render per product

For Meta Advantage+ catalog ads, Google Shopping-style display and any "every product, every size" job, each product is a set of modifications. Map the feed's columns (title, price, sale_price, image_link) to the template's fields, render one ad per product, and put each URL back next to its row.

Orshot renders the images and returns hosted URLs. It does not upload ads to Meta Ads Manager, Google Ads or LinkedIn Campaign Manager. The ad platform reads the image links from a feed.

Shopify stores: use the Orshot Shopify app (docs).

• The user installs Orshot from the Shopify App Store. On the Shopify page in Orshot they pick "ad images", pick the template, and turn the workflow on for added or edited products, with a one-time run for the existing catalog.
• Name the template's fields with the Shopify parameter names in those docs and they fill from each product with no mapping. Any other template is mapped once on that page.
• Ad images go to Shopify Files and to an ads feed that Meta Commerce Manager and Google Merchant Center read as a supplementary feed. The product's main image is not replaced.
• Over MCP, orshot_list_connected_integrations shows whether Shopify is linked, and orshot_list_workflow_nodes lists the Shopify trigger (shopify_new_product) for a custom workflow.

Sheets, CSV and Airtable feeds. This is a recurring job, so set it up as automation:

• Check orshot_list_workspace_logs for the source the user already runs. n8n, Make, Zapier or their own code: add the render call there (on a schedule, read the feed, keep only changed rows, render, write the URL back).
• No orchestrator yet: Orshot Workflows. orshot_list_workflow_nodes returns the exact node keys, including Google Sheets, CSV and Airtable sources and a Google Sheets write-back step. Build with orshot_create_workflow as a draft and run it once with orshot_run_workflow after the user says yes.

For every feed:

• Sale logic lives in the feed step: when sale_price is lower, send offer, price and old_price; when it is not, send the price and "old_price.opacity": "0".
• Re-render only changed rows. A 500-product catalog in 3 sizes is 1,500 credits per full pass.

Animated banners (GIF and MP4)

For a short moving banner (a price that pops, a badge that pulses, 3 to 6 seconds), the same render tool takes format: "gif" or "mp4". A video ad over 6 seconds, or with footage, voiceover or more than one scene, is a film: load orshot-video-generator alongside this skill and use them as a pair. This skill sets the offer, the hook, the product photo, the sizes and the CTA, and designs the static end card. The video skill builds the scenes that lead to it (the "Video ad" format from orshot_plan_design).

• GIF and MP4 need a plan with video rendering. The Free plan renders neither. Check orshot_get_account first.
• Add motion to the template (enter animations, showAt, motion; see Template JSON). Frame 0 must already show the product and the offer.
• Check the layout with a still first: format: "png" with responseType: "base64" costs one image credit and shows the first frame. Then render the motion once.
• videoOptions sets duration and fps (video options). A lower fps makes a smaller GIF. GIF has no audio. Animated output is billed per second.
• extraSizes does not work for GIF or MP4. Render each animated size as its own call with size (for example size: "medium-rectangle-ad", then size: "320x50"), and look at each one. A size saved in the Smart Resize panel renders as arranged.
• Display networks cap file size. Keep GIFs short, small and low on fps; check the network's limit before you upload.
• Long renders: pass background: true and collect with orshot_get_render_job.

Gotchas

1. Modifications key by parameterId, never by layer name. Read orshot_get_studio_template_modifications first.
2. Style overrides like "old_price.opacity" only reach parameterized layers (style parameters).
3. Keep ad templates single page; sizes come from Smart Resize, not pages. On a multi-page template a key without a pageN@ prefix reaches no page.
4. Image URLs must be public. Feed image links behind auth or signed links that expire fail the render.
5. Rendering does not run an ad. A render can be posted as organic content with orshot_publish_social_post, but that is not a paid ad and is never the default.
6. A 9:16 variant made by Smart Resize keeps the feed layout's logic. Check the top 250 px as well as the bottom 380 px for text, and look for stretched stickers and empty bands.
7. Do not make a new template per campaign. Swap the colour, offer and image fields instead.
8. Serif faces with old-style figures (Cormorant, Playfair) make prices like "$110" hard to read. Set prices in a face with lining figures.

Safety

• Never invent a discount, price, deadline or review. Use the numbers the user or the feed gives you, and ask when one is missing.
• No fake scarcity ("only 2 left") unless the data says so. No competitor logos or trademarks without the user's say-so.
• Rebuild layouts only with the user's own brand, images and words. Never copy another brand's ad, and never scrape ad libraries.
• Say the credit cost before any batch over 10 renders and before any feed run, and wait for a yes.
• Show the first render of a new template before running a batch or a feed.
• Ask before importing anything into the brand kit.

Related skills: orshot (API, render options, automation), orshot-design (design craft rules), orshot-social-media-content (organic posts from the same brand), orshot-carousel (carousel ads and posts), orshot-video-generator (video ads, used as a pair), orshot-social-media-scheduler (posting organic content).