Make OG images and screenshots with the HTTP "Make a request" module

To generate Open Graph images or website screenshots in Make (formerly Integromat), use the built-in HTTP app's Make a request module: method POST, URL https://shareglint.com/v1/images?wait=true (or /v1/screenshots?wait=true), an API key keychain that sends Authorization: Bearer sk_live_…, and an application/json body built from the trigger's fields. The response contains the finished file's public url for the next module. There is no official Shareglint app in Make's directory yet; the HTTP module is the supported way and covers every endpoint.

Each new image uses one render of your monthly quota (100 free); requesting the same image twice costs nothing the second time.

Set up the request module

Make's HTTP app documentation lists the fields of Make a request. For Shareglint:

Authentication type: API key. Create a keychain as Make describes in its API key authentication guide:

• Key: Bearer sk_live_… — the whole header value, including Bearer and the space.
• API key placement: In the header.
• API key parameter name: Authorization.

The keychain keeps the key out of the module settings, so cloning or sharing the scenario does not copy the key. Create a separate key for Make in the Shareglint dashboard so you can revoke it alone.

Then the request itself:

• URL: https://shareglint.com/v1/images?wait=true
• Method: POST
• Body content type: application/json
• Body input method: Data structure — Make escapes quotes and other JSON reserved characters in mapped values for you. With JSON string you must escape them yourself, which fails on the first title containing ".
• Parse response: Yes, so url, status and id become mappable fields.
• Return error if HTTP request fails: see the error section below.

?wait=true keeps the connection open until the image is ready. If you take full-page screenshots or animated renders, raise the module's Timeout so Make does not give up before the API answers.

The data structure

A data structure describes the JSON once; you then map values into it. For template renders, create one with:

Make sends it as:

{
  "template": "blog-og",
  "format": "jpeg",
  "modifications": {
    "title": "Why we moved to Postgres",
    "eyebrow": "Blog",
    "author": "Maya Chen",
    "site": "yourblog.com"
  }
}

The fields of every built-in template are in the template gallery and the docs. A field you leave out takes the template's default.

The answer (status 200, abridged):

{
  "id": "img_01m08…",
  "kind": "image",
  "status": "completed",
  "format": "jpeg",
  "width": 1200,
  "height": 630,
  "url": "https://…/img_01m08….jpg"
}

Recipe 1: a card for every new RSS item

RSS → Watch RSS Feed Items → HTTP → Make a request → for example Google Sheets → Add a Row, a CMS module or a social scheduler.

In the request's data structure, map the RSS item's title into modifications.title from the mapping panel, and keep eyebrow and site fixed. After the module, map url from the HTTP module's output wherever the image should go. To render the post for Instagram too, add sizes (Array of Text: og, square) to the structure instead of a single size; the response then has renders, one per size, each a render of quota.

Recipe 2: product cards from Google Sheets

Google Sheets → Watch New Rows → HTTP → Make a request → Google Sheets → Update a Row.

With the product-og template, map the columns into modifications: name, tagline, price, and an image column into screenshot (image fields take a public URL). Write url back into the row with Update a Row, using the row number from the trigger.

For a sheet that already holds hundreds of products, do not run one request per row. A single request to POST https://shareglint.com/v1/batches with template and csv_url set to the sheet's share link renders every row, checks the whole batch against your quota before starting, and returns progress and a ZIP — see bulk images from a sheet. Batch limits by plan: Free 50, Starter 500, Pro 1,000, Scale 2,000, Business 5,000.

Recipe 3: a website screenshot

Point a second Make a request module at POST https://shareglint.com/v1/screenshots?wait=true with a data structure like:

{
  "url": "https://example.com/pricing",
  "device": "iphone-15",
  "full_page": true,
  "lazy_load": true,
  "block_cookie_banners": true,
  "format": "webp"
}

Map url from a webhook (Webhooks → Custom webhook), a sheet or an RSS item's link. The response has the same shape with kind: "screenshot". A viewport shot costs 1 render, a full page 2; the same page with the same options within 24 hours is free. Only public http(s) pages can be captured: a private or local address is refused with a 422, and a page that fails to load returns status: failed with its render refunded.

Errors: 402, 429, 503

The module's Return error if HTTP request fails decides what a 4xx or 5xx does. Yes stops the scenario at the error (handled by error handlers); No passes the response on, so you can route on the status code with filters. Plan for these:

For 429 and other temporary failures, Make's own tools fit: enable Store incomplete executions in the scenario settings and add a Retry error handler to the HTTP module, which retries a failed bundle after an interval (Make's retry handler). For instant triggers, Make recommends capping Maximum runs to start per minute on the trigger; for scheduled ones, fewer records per run (fixing rate limit errors). A big list is cheapest as one batch request anyway.

No double renders on retry. Add a header Idempotency-Key with a value unique to the bundle (the RSS item link, the row number). A retry with the same key and body returns the first response instead of rendering again. And independently of that, the same template with the same fields always reuses the existing image.

Why not an MCP or a dedicated app?

A dedicated Make app would mostly wrap these same requests in friendlier field names; until one is listed in Make's directory, the HTTP module gives you the full API with nothing extra to install or trust. If you want an AI assistant to make images instead of a fixed scenario, connect it through the MCP server. The same recipes for n8n are in the n8n guide.