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

> Generate Open Graph images and website screenshots in Make with the HTTP Make a request module: API key keychain, JSON body, RSS, Sheets, errors.

Published 2026-11-04 · https://shareglint.com/en/integrations/make

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](https://apps.make.com/http) 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](https://apps.make.com/api-key-authentication-type):

- **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:

| Key | Type | Example |
|---|---|---|
| `template` | Text | `blog-og` |
| `format` | Text | `jpeg` |
| `modifications` | Collection | `title`, `eyebrow`, `author`, `site` (Text) |

Make sends it as:

```json
{
  "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](https://shareglint.com/en/templates) and the [docs](https://shareglint.com/en/docs). A field you leave out takes the template's default.

The answer (status `200`, abridged):

```json
{
  "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](https://shareglint.com/en/guides/bulk-og-images-from-csv-google-sheets). 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:

```json
{
  "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:

| Status | `error` | In Make |
|---|---|---|
| `402` | `quota_exceeded` | Route to an email or Slack notification and stop. Retrying does not help until the quota renews or you add a top-up; nothing was charged. |
| `429` | — | Too many requests per minute for your plan. Wait and retry (`Retry-After` says how long). |
| `503` | `sync_overloaded` | The render is still running; fetch it later with `GET /v1/images/{id}` using the `id` in the body. |
| `422` | — | A mapped value is invalid (the `message` says which). Fix the mapping. |

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](https://help.make.com/retry-error-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](https://help.make.com/fix-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](https://shareglint.com/en/guides/og-images-with-ai-assistants-mcp). The same recipes for n8n are in the [n8n guide](https://shareglint.com/en/integrations/n8n).

## FAQ

### Is there an official Shareglint app in Make?

No. There is no Shareglint app in Make's app directory yet. The supported way is Make's built-in HTTP app and its Make a request module, with your API key in a keychain; it reaches every endpoint of the API.

### How do I keep titles with quotes from breaking the request?

Set Body input method to Data structure instead of JSON string. Make escapes JSON reserved characters in mapped values automatically; with a JSON string you have to escape them yourself, and a title like The "boring" stack breaks the body.

### What does a Make scenario cost in renders?

Each new image is one render against your Shareglint quota (100 a month on the Free plan), a viewport screenshot 1 and a full page 2. A request identical to an earlier one returns the existing image for free. Make's own operations are billed by Make separately.

### What happens when the quota runs out in the middle of a scenario?

The API returns 402 with error quota_exceeded and charges nothing. With Return error if HTTP request fails set to No, the scenario receives the response and a filter can route it to a notification instead of stopping.