How to Add a Website Screenshot to a Trello Card with Make

To add a website screenshot to a Trello card with Make, connect a URL screenshot action to Trello’s Add an Attachment action. If the scenario should create a card too, put Trello’s Create a Card action before the attachment action. Map the screenshot module’s actual output to the attachment input shown in your Make editor; the available documentation does not specify exact field names, so confirm them in the live module instead of guessing.

Make lists Create a Screenshot of a URL in its HTML/CSS to Image integration and Create a Card and Add an Attachment in its Trello app. See Make’s Trello and HTML/CSS to Image integration and Make’s Trello app documentation.

1. Choose the card workflow

Decide whether the automation should create a new card or attach the screenshot to a card that already exists. The screenshot step is the same in both cases; the difference is how you identify the destination card.

Workflow	Use it when	Card selection
Create a new card	Each incoming URL should start a new task or record.	Run Create a Card first, then use its returned card identifier if the attachment module accepts it.
Attach to an existing card	A card already represents the website or task.	Select or provide the target card using the identifier or shortlink accepted by the live module.

Make’s Trello documentation says some card operations require a card ID or shortlink. The documentation describes getting card identifiers from trigger output, such as a New Card trigger. To find a card shortlink, open the card, choose Share, and use the part of its URL after https://trello.com/c/. Check which identifier the current attachment module expects.

2. Build the scenario

Create a scenario. Choose a trigger that supplies the website URL, or use a manually supplied URL if you intend to start the scenario on demand. The Make documentation does not prescribe a particular trigger.
Add the screenshot action. Search the app list for HTML/CSS to Image and choose Create a Screenshot of a URL. Enter or map the page URL you want captured.
Add the destination card step. For a new card, add Trello’s Create a Card before the attachment step and configure the destination board and list in the module. For an existing card, use the existing-card path and identify the correct card.
Add Trello’s attachment action. Select Add an Attachment, choose the destination card, and inspect the module’s required fields.
Map the screenshot output. Expand the screenshot module’s output bundle in the scenario editor. Map the returned image or file, or image URL if that is what the module returns and Trello accepts, to the matching attachment input exposed by the live module.
Run a scenario test. Use a page you can access, inspect the run’s module outputs, and check that the intended image appears on the intended card. This is a recommended verification step; the cited documentation confirms module availability, not a tested end-to-end mapping.

3. Map the modules without guessing

The two official Make references establish that the screenshot and attachment actions are available, but they do not document the exact screenshot output property or Trello attachment input labels. These can vary with the module and current editor, so use the bundles shown in your own scenario.

Open the screenshot module’s output after a successful run and identify whether it provides image data, a file, or a URL.
Open the attachment module’s configuration and read its required inputs and accepted value types.
Map compatible output to input. If the output is a URL but the attachment module requires file data, use a supported download or file-handling step if the live Make app offers one; do not assume a URL field accepts binary data.
For a card created earlier in the scenario, map the identifier returned by Create a Card into the attachment action’s card selector or identifier input, as supported by the editor.
For an existing card, verify the card name, board, and list before running the scenario. A valid identifier for the wrong card can still attach the screenshot successfully to the wrong place.

4. Make the scenario dependable

Handle missing or unusable URLs

Make sure the trigger provides a complete URL, including its scheme, such as https://. If URLs come from user input or another system, add validation or a filter before the screenshot step so empty or malformed values do not create failed runs.

Check the result before attaching

Inspect the screenshot action’s output during setup. If it returns an error, empty result, or unexpected format, resolve that at the capture step before mapping it to Trello. A test with one known public page helps isolate whether a problem comes from URL input, capture output, card selection, or attachment mapping.

Avoid accidental duplicate cards

If each run creates a new card, repeated trigger events can create repeated cards. Decide whether that is intended. If not, use a trigger or scenario condition that identifies the intended single event, or route the screenshot to a known existing card. The cited documentation does not specify a deduplication feature for this workflow.

Verify the target card and attachment

After a test run, open the card and check both its identity and the attachment. For an existing-card scenario, verify the selected identifier or shortlink. For a new-card scenario, verify the identifier passed from the create step is the one used by the attachment action.

5. Troubleshoot common problems

Symptom	Likely cause	What to check
No screenshot is attached.	The screenshot output was not mapped, or the mapped value is incompatible with the attachment input.	Inspect the screenshot output bundle and the attachment module’s required input type. Map the compatible value shown in the editor.
The scenario cannot find the card.	The card identifier or shortlink is missing, malformed, or not the type the module expects.	Use a card identifier returned by a preceding trigger or create step when available. For an existing card, retrieve its shortlink through Share and confirm the module’s accepted identifier type.
The screenshot action fails.	The URL may be empty, malformed, inaccessible, or the capture action may have returned an error.	Check the exact URL passed to the module and inspect that module’s run output before debugging Trello.
The attachment goes to the wrong card.	The selected card or mapped identifier points to a different destination.	Confirm board, list, card name, and identifier in the scenario run and on the resulting card.
The image is missing or unusable.	The screenshot output may be a URL or other value where the attachment input expects a file, or the capture may not have produced a valid image.	Check the output’s actual type and use a compatible input or supported file-handling step offered by Make.
A new card appears every time the scenario runs.	The scenario creates a card on each execution.	Use the create-card path only when each run should create a card; otherwise target an existing card or constrain which trigger events proceed.

6. Performance, reliability, and cost considerations

This workflow has two dependent operations: capture the page, then attach its result to the card. If the capture step fails or returns an incompatible result, the attachment cannot be completed. If the card step fails, the screenshot cannot be attached to that destination. Inspect each module’s run output separately to locate the failing step.

Capture time and image size depend on the target page and the screenshot service’s behavior. The cited Make material does not provide timing, reliability, or pricing figures for this specific scenario, so check the current Make and app plans for your expected volume. Keep the captured image limited to what the Trello card needs, and test representative pages that have the same access requirements as your real inputs.

Or skip the browser setup

ScreenshotNeo provides a website screenshot API and MCP server. One GET request can return a PNG, JPEG, WebP, or PDF. To use the screenshot in this Make flow, call the API and map its returned response in the way the live Make attachment module accepts; verify the response-to-attachment mapping in the editor.

See the ScreenshotNeo API documentation. This cURL request saves a WebP screenshot of Stripe:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python equivalent:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
with open("shot.webp", "wb") as image_file:
    image_file.write(r.content)

Node.js equivalent:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());

Cookie and consent banners, newsletter popups, and chat widgets from more than 60 known platforms are handled before capture; each step can be turned off.
Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. Responses include X-Page-Verdict and X-Billed headers.
An MCP server offers take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
The free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 screenshots. Every feature is on every plan.

FAQ

Can Make create the Trello card and attach the screenshot in one scenario?

Make lists both Create a Card and Add an Attachment for Trello. Put card creation before the attachment step and map the returned card identifier using the field shown in the editor.

Can I attach a screenshot to a card that already exists?

Yes. Select or provide the target card in the attachment action. Confirm whether the current module expects a card ID, shortlink, or another value.

Does the documentation specify the exact screenshot output field?

The references establish that the screenshot and attachment actions exist, but do not give exact field names for mapping. Inspect the live Make module’s output and required inputs.

What identifier can I use for an existing Trello card?

Make’s Trello documentation describes card IDs and shortlinks for some operations. It explains that a shortlink appears in the card URL after https://trello.com/c/; use the identifier type the attachment module accepts.