Automate product thumbnail generation, social preview images, and competitor price monitoring with one screenshot API. Works with Shopify, WooCommerce, and custom storefronts.
Start Free — 200 Screenshots/moModern e-commerce operations generate a constant need for automated image capture. Product page screenshots for social sharing, OG images for every product listing, visual confirmation of promotional banners going live, competitor product page snapshots for price monitoring, and automated quality checks on new product listings are all tasks that benefit from a reliable screenshot API.
SnapAPI handles all of these from a single integration point. Your Shopify store, WooCommerce installation, or custom storefront gets a REST endpoint that converts any URL into a CDN-hosted image. No headless browser to deploy, no screenshot service to maintain — just HTTP calls from your existing backend.
Every product listing needs a unique Open Graph image for social sharing. When customers share product links on social media, the preview image determines whether their followers click through. Generate a custom OG image for each product by capturing a dedicated template page populated with the product's name, price, and image.
# Generate OG image for a Shopify product
def generate_product_og_image(product_id, product_title, price):
template_url = (
f"https://yourstore.com/og-product"
f"?id={product_id}"
f"&title={urllib.parse.quote(product_title)}"
f"&price={price}"
)
result = requests.get("https://snapapi.pics/v1/screenshot", params={
"access_key": SNAPAPI_KEY,
"url": template_url,
"width": 1200,
"height": 630,
"format": "png",
}).json()
return result["url"]Track competitor product pages visually to monitor price changes, out-of-stock notifications, and promotional changes. Schedule daily screenshots of key competitor pages and compare them visually or extract price text using SnapAPI's extract endpoint.
# Extract price from a competitor product page
result = requests.get("https://snapapi.pics/v1/extract", params={
"access_key": SNAPAPI_KEY,
"url": "https://competitor.com/product/123",
"selectors": json.dumps({
"price": ".product-price",
"availability": ".stock-status",
"title": "h1.product-title"
})
}).json()
print(f"Competitor price: {result['price']}\nIn stock: {result['availability']}")When marketing launches a sale or promotional campaign, automatically verify that banners are displaying correctly across key pages. Capture screenshots of your homepage, category pages, and product pages immediately after deployment, then compare against pre-deployment baselines.
# Shopify webhook: verify homepage after theme update
def handle_theme_published(webhook_data):
pages_to_verify = [
"https://yourstore.com/",
"https://yourstore.com/collections/sale",
"https://yourstore.com/cart",
]
screenshots = {}
for url in pages_to_verify:
result = requests.get("https://snapapi.pics/v1/screenshot", params={
"access_key": SNAPAPI_KEY,
"url": url,
"width": 1440,
"full_page": True,
}).json()
screenshots[url] = result["url"]
notify_team(screenshots) # Post to Slack with screenshot URLsConnect SnapAPI to Shopify webhooks to automatically generate screenshots when products are created or updated. Register for the products/create and products/update webhooks in your Shopify Partner app or custom app, then fire a screenshot job for each new or updated product page.
For WooCommerce stores, hook into the woocommerce_new_order and save_post_product actions to trigger screenshot generation. Use WordPress's wp_remote_get() to call SnapAPI, or add a background processing job via Action Scheduler to avoid slowing down admin operations.
A typical e-commerce store with 1,000 products needs 1,000 OG image generations (one-time batch) plus ongoing screenshots for new products and monitoring. The Starter plan at $19/month covers 5,000 screenshots — enough for the initial batch plus months of ongoing generation. Growth at $79/month covers large catalogs (50,000 screenshots) and frequent monitoring runs. Start free today.
If you're building a Shopify app that needs screenshots for merchants, the integration is straightforward. Use Shopify's App Bridge to authenticate, access the merchant's storefront URL, and call SnapAPI from your app's backend (Node.js, Ruby on Rails, or Python are all common Shopify app backends).
// Node.js Shopify app backend
const Shopify = require('@shopify/shopify-api');
app.post('/api/generate-og-images', async (req, res) => {
const session = res.locals.shopify.session;
const client = new Shopify.Clients.Rest(session.shop, session.accessToken);
// Fetch all products
const products = await client.get({ path: 'products', query: { limit: 250 } });
const results = [];
for (const product of products.body.products) {
const productUrl = `https://${session.shop}/products/${product.handle}`;
const snap = await fetch(
`https://snapapi.pics/v1/screenshot?access_key=${process.env.SNAPAPI_KEY}&url=${encodeURIComponent(productUrl)}&width=1200&height=630`
);
const { url } = await snap.json();
results.push({ product_id: product.id, og_image: url });
}
res.json({ generated: results.length, results });
});WooCommerce's Action Scheduler (bundled with WooCommerce) is the right tool for background screenshot generation. Schedule screenshot jobs when products are created or updated, then run them asynchronously without blocking the admin UI.
// functions.php or custom plugin
add_action('save_post_product', 'schedule_product_screenshot', 10, 1);
function schedule_product_screenshot($post_id) {
as_schedule_single_action(
time() + 30, // 30 seconds after save
'generate_product_screenshot',
['product_id' => $post_id]
);
}
add_action('generate_product_screenshot', 'do_generate_product_screenshot', 10, 1);
function do_generate_product_screenshot($args) {
$url = get_permalink($args['product_id']);
$response = wp_remote_get(add_query_arg([
'access_key' => SNAPAPI_KEY,
'url' => $url,
'width' => 1200,
'height' => 630,
], 'https://snapapi.pics/v1/screenshot'));
$body = json_decode(wp_remote_retrieve_body($response), true);
update_post_meta($args['product_id'], '_og_image_url', $body['url']);
}A store with 5,000 products needs 5,000 OG image generations. On SnapAPI's Growth plan at $79/month (50,000 screenshots), that's the entire initial batch plus 45,000 remaining credits for ongoing monitoring, new product screenshots, and promotional verification throughout the month. If you add daily monitoring of 20 key pages, that's 600 screenshots per month — trivial within the plan allowance. For larger catalogs (50,000+ products), custom enterprise plans with volume pricing are available. The economics are compelling: automated OG image generation that increases social sharing CTR by even a few percentage points has a payback period measured in days, not months.
Start with the free tier to verify the integration works for your store, then upgrade as you scale. Create your free SnapAPI account.
Beyond the basic product screenshot use cases, several advanced e-commerce workflows benefit from screenshot APIs. Flash sale verification is one example: when a time-limited sale goes live, automatically capture screenshots of the homepage, sale landing page, and top product pages within seconds of launch. If the promotional pricing or banners are not displaying correctly, catch it immediately rather than discovering the issue via customer complaints an hour later.
Marketplace seller monitoring is another high-value use case. If you operate a marketplace where third-party sellers list products, periodically screenshot their product pages to verify that images, descriptions, and pricing comply with your marketplace policies. Human moderators can quickly review visual snapshots rather than navigating to each listing manually.
Abandoned cart email personalization is an emerging use case: capture a screenshot of each product in the abandoned cart and embed the images directly in the recovery email. Instead of relying on product images from your CDN (which may be missing or stale for some products), SnapAPI captures exactly what the product page looks like at the moment the email is sent.
For headless commerce architectures using Shopify Hydrogen, CommerceJS, or custom frontends with Contentful or Sanity as the CMS, SnapAPI integrates at the API layer rather than requiring a platform-specific plugin. Your backend service calls SnapAPI; the resulting CDN URL gets stored in your CMS alongside the product data. This works regardless of which headless framework your frontend uses.
# Contentful: update product entry with generated OG image
import contentful_management
import requests
client = contentful_management.Client(CONTENTFUL_TOKEN)
space = client.spaces().find(SPACE_ID)
env = space.environments().find('master')
for entry in env.entries().all(query={'content_type': 'product'}):
product_url = f"https://yourstore.com/products/{entry.fields()['slug']}"
snap = requests.get('https://snapapi.pics/v1/screenshot', params={
'access_key': SNAPAPI_KEY,
'url': product_url,
'width': 1200, 'height': 630,
}).json()
entry.og_image = {'en-US': snap['url']}
entry.save()
entry.publish()International stores often need locale-specific screenshots — different prices, currencies, and language content for each market. Pass locale parameters in your URL and capture locale-specific screenshots for each market's OG images and social content. SnapAPI renders the page as it actually appears, so locale switching handled by your frontend JavaScript is captured correctly.
E-commerce teams that have integrated SnapAPI report the most value from OG image generation (measurable CTR improvement on social sharing), post-deploy verification (catching visual regressions before customers do), and competitor monitoring (pricing intelligence that used to require manual checks). All three integrate in a day of engineering time and deliver ongoing value with zero additional maintenance. Start free and see the impact on your store.
E-commerce teams that delay implementing automated OG image generation consistently report the same experience: once they launch it, social sharing metrics improve within the first week and they wish they had done it sooner. The implementation is a single afternoon of work for most storefronts. The SnapAPI free tier gives you two hundred credits to build and validate the entire workflow before spending anything. If your store has fewer than two hundred products, you can generate your entire initial OG image library on the free tier. For larger catalogs or ongoing monitoring, upgrade to Starter at nineteen dollars per month. The math works in your favor from day one. Start building your e-commerce screenshot integration today.