How to Prompt with Images in ChatGPT (Screenshots, Photos, Diagrams)

TL;DR: A ChatGPT image prompt input works when you say what to do with the picture, not what it is. Tell the model what the image shows, point at the region that matters, ask it to transcribe before it reasons, and check every number against the image. Vision models misread confidently and never flag it.

What is a ChatGPT image prompt input?

It is an attachment plus an instruction, and the instruction is the part people skip.

An image on its own is not a question. You know why you took the screenshot; the model does not. It sees a rectangle of pixels with no filename, no folder path and no memory of the tab you were on. OpenAI states this outright in its ChatGPT image inputs FAQ: "The model doesn't process original file names or metadata, and images are resized before analysis, affecting their original dimensions" (accessed 28 August 2026). The context you think you attached did not come with the file.

So the whole discipline reduces to one habit. OpenAI's own ChatGPT documentation for image inputs says it in a sentence: "Explain what ChatGPT should inspect and what outcome you want; don't rely on the image alone to communicate the task." The same page's guidance for writing the prompt is equally blunt: "Name what the image shows, point to the area that matters, and state the output and constraints."

That is the shape. Everything else on this page is that shape, specialised by what you happen to be holding.

Why does "what is this?" get a worse answer than "do this with it"?

Because "what is this" invites a description, and a description is almost never the job.

Ask a model what a screenshot is and it will tell you: a settings page, a bar chart, a handwritten note. Correct, useless, and expensive in tokens. The task you actually had was to find the misconfigured field, to compare Q3 against Q2, or to turn the note into a checklist. Naming the task changes what the model attends to inside the image, which is the entire mechanism you are steering.

Three universal shapes, before we get to specific artefacts.

This image is a [what it is: a screenshot of X, a photo of Y, a scan of Z].
Task: [the verb — extract / compare / diagnose / convert / rewrite].
Focus on: [the region — the top-right panel, the third column, the axis labels].
Output: [the format — a table, a numbered list, valid JSON, a paragraph].
If something is unreadable, say "UNREADABLE" rather than guessing it.

Before you answer, transcribe everything you can read in this image, verbatim,
in reading order. Mark anything ambiguous with [?]. Stop there. Do not interpret
or analyse anything yet. I will confirm the transcription before we continue.

Answer only from what is visibly present in this image. For anything I have
asked about that is not visible, write "NOT VISIBLE IN IMAGE" and move on.
Do not infer, complete, or fill in from typical patterns.

How do you stop a model from misreading an image?

You do not stop it. You make the misread visible before it becomes a conclusion.

This is the honest core of the page and it deserves its own heading. A vision model turns pixels into characters by inference, the same way it turns a half-finished sentence into a whole one. When the inference is wrong, nothing in the output looks different. A 3 read as an 8, a column boundary placed one pixel left, a legend entry mapped to the wrong series, a handwritten "lease" read as "least": all of it arrives in the same calm prose as the parts it got right.

The vendors document this in their own words. Anthropic's vision guide lists under Limitations that "Claude might hallucinate or make mistakes when interpreting low-quality, rotated, or very small images under 200 pixels", and separately that "Claude can give approximate counts of objects in an image but might not always be precisely accurate, especially with large numbers of small objects" (accessed 28 August 2026). OpenAI's ChatGPT limitations list warns that "The model may misinterpret rotated / upside-down text or images."

Two-step prompting costs one extra turn and catches the class of error that is otherwise undetectable. It matters most for charts, tables, invoices, lab values and anything you will act on.

Step 1 of 2. Transcribe this table exactly as it appears: every header, every
row, every cell, preserving the original order. Use a pipe-delimited format.
Where a cell is cut off or illegible, write [CUT] or [ILLEGIBLE].
Do not compute anything. Do not comment. Transcription only.

Step 2 of 2. I have checked your transcription and corrected two cells; the
corrected version is below. Work only from this corrected text from now on, not
from the image. [paste corrected transcription]
Now: [the actual analysis you wanted].

Read the value at [specific location, e.g. "the third bar from the left"] and
state your confidence as high, medium or low. If it is medium or low, say what
about the image makes it uncertain rather than picking the likeliest value.

What is the right prompt for a screenshot of an error or a UI?

Give it the surrounding facts the screenshot cannot carry, then ask for a diagnosis rather than a reading.

An error screenshot is missing everything the model needs: what you were doing, what you expected, which version you are on, what you already tried. A stack trace in a picture is still just a stack trace. The prompt is where the reproduction context goes, and it is why a bug-report prompt and an error-screenshot prompt are close relatives. If you do this regularly, our bug report prompt generator produces the surrounding structure for you.

Screenshot of an error dialog from [app + version] on [OS].
I was doing: [action]. I expected: [result]. I got this instead.
Already tried: [list].
Transcribe the exact error text first, then give me the three most likely causes
ranked by probability, and the single cheapest check that would distinguish them.

This is a screenshot of a terminal after running [command].
Read the full traceback, then tell me: which line in MY code is the first one in
the stack, and what is the smallest change that would fix it. Ignore frames
inside third-party libraries unless they are the actual cause.

Screenshot of the [name] settings page. Our requirement is [requirement].
List every setting visible in this screenshot that is inconsistent with that
requirement, as a table of: setting name, current value, required value.
If a required setting is not visible in this screenshot, list it separately
under "NOT VISIBLE" rather than assuming its value.

Two screenshots: the first is the working state, the second is after [change].
Identify every visible difference, ordered by how likely each is to be the cause
of [symptom]. Ignore cosmetic differences like timestamps and cursor position.

How do you prompt with a photo of handwriting or a whiteboard?

Transcribe first, always, and tell it who wrote it and why.

Handwriting is the case where confident misreading is most likely and least visible, because there is no canonical text to check against except the photo in your hand. Whiteboards add glare, angle and the arrows that carry half the meaning. Say what the session was about; domain context is what lets a model choose "sprint" over "spint".

Photo of a whiteboard from a [type of session] about [topic].
Transcribe every word and label exactly as written, including anything in the
margins. Preserve the arrows as "A -> B" relations. Mark uncertain words [?].
Do not tidy up abbreviations or expand them. Transcription only.

Photo of handwritten meeting notes, written by me during [meeting].
Convert to a structured list: decisions made, open questions, action items with
an owner where one is named. Anything you cannot read confidently, put in a
final "COULD NOT READ" section with your best guess in brackets.

This is a photo of a handwritten formula/equation on paper.
Transcribe it to LaTeX exactly as written, including any errors.
Then, separately, tell me whether it is correct, and if not, where.
Do not silently fix anything during transcription.

How do you get a model to read a chart or graph correctly?

Make it state the axes and the scale before it states a trend, and treat any number it produces as a draft.

This is the highest-risk artefact on the page, and the vendor says so. OpenAI's limitations list for ChatGPT image inputs includes a bullet headed Visual elements: "The model may struggle to understand graphs or text where colors or styles like solid, dashed, or dotted lines vary." That is exactly a chart with three series, a dashed forecast line and a legend. Log scales, truncated y-axes and dual axes all compound it, because the model reads the drawing, not the underlying data.

Chart image. Before any interpretation, tell me:
1. The chart type. 2. What the x-axis measures, with its range and units.
3. What the y-axis measures, with its range, units, and whether it starts at zero
   or is truncated. 4. Every series in the legend and its visual style.
Stop there. Do not describe the trend yet.

Now read the values. For each series, give me the value at each labelled x-axis
tick, in a table. Where a value is between gridlines, give a range rather than a
point estimate. Mark any value you are reading off an unlabelled position as
ESTIMATED.

I have verified the values below against the chart. [paste corrected table]
Using only these numbers, answer: [your actual question].
Do not re-read the image.

What about a table or a spreadsheet screenshot?

Force the column boundaries into the open, because that is where this one breaks.

A screenshot of a spreadsheet loses the thing that made it a spreadsheet: the cell structure. The model has to re-derive where one column ends and the next begins from whitespace, and merged cells, wrapped text and right-aligned numbers all attack that. Ask for the header row as an explicit list before you ask for a single row of data.

Screenshot of a spreadsheet region.
First: list the column headers, left to right, numbered. Then list the number of
data rows visible. Stop and let me confirm before transcribing any data.

Transcribe this table to CSV. Quote every field. Preserve empty cells as empty
quoted fields rather than skipping them, so the column count is identical on
every row. If a row has a different number of cells from the header, flag it.

This screenshot shows rows [range] of a longer sheet; the rest is not visible.
Answer only about the rows shown, and state that scope in your answer.
Do not extrapolate a total, an average or a trend to the full sheet.

How do you prompt with a diagram or an architecture sketch?

Ask it to list the nodes and edges before it offers an opinion about the design.

Diagrams carry meaning in position, arrow direction and grouping boxes, and those are precisely the spatial relationships models handle least well. OpenAI lists spatial reasoning among its documented vision limitations. So separate structure extraction from critique: get the graph out as text, correct it, then argue about it.

Architecture diagram. Extract it as a list of components and connections:
- Components: name and type for each box.
- Connections: "A -> B: label" for every arrow, using the arrow's own direction.
- Groupings: which components sit inside which boundary boxes.
Mark anything whose direction or membership is ambiguous with [?].

Here is the corrected component and connection list. [paste]
Working only from this list, not the image: identify single points of failure,
any component with no inbound connection, and any cycle. One line each.

Hand-drawn sketch of a proposed data flow.
Convert it to a written specification: for each step, the input, the transform,
the output, and the failure mode if the previous step returns nothing.
Where the sketch is silent about something a spec needs, list it under
"UNSPECIFIED IN SKETCH" instead of choosing a default.

What is the right way to prompt with a document scan?

Screenshot the page rather than uploading the PDF, and never let it summarise before it transcribes.

This one has a trap that is documented and widely missed. OpenAI's File Uploads FAQ states that outside Enterprise visual retrieval, "All other plans and document files only support text-based retrieval. This means that ChatGPT will extract digital text from the file and discard any images" (accessed 28 August 2026). A scanned page is an image inside a PDF wrapper. Upload it as a document and the extraction step can hand the model very little. Export the page to PNG and attach it as an image instead, and the vision path actually runs.

Scan of a [document type], page [n] of [total].
Transcribe the full page verbatim, preserving paragraph breaks, headings and
any numbering. Do not summarise, correct spelling, or modernise wording.
Illegible passages: write [ILLEGIBLE] with the approximate word count.

From the transcription above, extract these fields into JSON:
[field list]. For any field not present in the text, use null — never a guess.
Add a "confidence" key per field with high/medium/low.

This is a scan of a signed [contract/form]. Do not interpret it legally.
List, as bullet points, only: dates present, named parties, monetary amounts,
and any handwritten annotation or crossing-out. Quote each exactly as written.

How do you prompt with a photo of a physical object?

Say what you want decided, and give it the scale reference it has no way to infer.

Photos of objects arrive with no size information. A model cannot tell a 4mm screw from a 40mm one unless something known is in frame, and it will not usually announce the gap. Put a coin, a ruler or a common object in the shot, and say what it is in the prompt.

Photo of a [component/part]. The object next to it is a [known object] for scale.
Identify the type of part, its likely standard or thread size, and the two most
useful measurements to take with calipers to confirm.
If the photo does not support an identification, say so rather than guessing.

Photo of [equipment] showing a fault. Nothing has been disassembled.
List what is visibly abnormal, then list what would need to be checked that is
NOT visible in this photo. Do not speculate about internal condition.

Photo of a product label. Transcribe every line of text on the label exactly,
including small print, model numbers and any certification marks you can read.
Mark anything cut off by the edge of the frame as [CROPPED].

How do you turn a design mockup into a spec?

Ask for the things a picture cannot show, and be explicit that the image is a target, not a description.

A mockup shows one state of one screen. It says nothing about hover, focus, validation, empty states, error states, loading, or what happens at 320 pixels wide. OpenAI's own prompting guide makes this point for the Codex workflow: "Include behavior the image doesn't show in text, such as hover states, validation rules, or keyboard interactions." The same logic applies whether you are handing it to a person or to a UI generator like the ones in our v0 templates.

Design mockup for [screen name]. Treat this as the target visual, not a spec.
Produce a component inventory: for each distinct UI element, give a name, its
type, its visible content, and its apparent state (default/disabled/selected).
Do not propose implementation yet.

From that inventory, write the spec gaps: for every interactive element, list the
states the mockup does not show (hover, focus, error, loading, empty) and the
question I need to answer for each. Do not invent answers.

Two images: [1] the design, [2] a screenshot of the current build.
List every discrepancy as: element, designed value, built value, severity.
Spacing and typography only. Ignore differences in placeholder content.

What are the documented limits for images, per vendor?

They differ by product and by surface, and only some of them are published at all.

The table below is only what each vendor states on its own pages, with the surface named, because a limit for an API is not a limit for a chat window. Where a vendor does not publish a number, the honest cell says so rather than borrowing a figure from a blog. These change often, so check the linked pages rather than trusting a table you read once.

Sources, in order: OpenAI's ChatGPT Image Inputs FAQ and File Uploads FAQ for the ChatGPT column and Images and vision for its API row; Anthropic's Vision guide for Claude; Google's Upload and analyze files in Gemini Apps and Image understanding for Gemini. All accessed 28 August 2026.

Two nuances worth carrying away. First, OpenAI declines to give a per-prompt image count at all: "The number of images you can add to a conversation depends on various factors, including the size of the images and the amount of text accompanying them." Second, Google's Gemini API documentation offers a tip that reads like a formatting detail and is not: "When using a single image with text, place the text prompt before the image in the input array." If you are calling the API, order matters.

What should you crop out before you upload?

More than you think, and cropping is also the single cheapest accuracy win available.

Every major vendor downsizes large images before analysis. That means a full 4K screen capture spends most of its resolution budget on the parts you did not care about, and the error text you actually wanted read arrives smaller than it needed to be. Anthropic's quality guidance says to consider pre-resizing or cropping, while warning against overcorrecting: "Avoid cropping out key visual context solely to enlarge the text." Crop to the region plus enough surroundings to make it interpretable.

The privacy half is more serious. A screenshot is a photograph of your working life: open tabs, the customer name in the tab title, a ticket ID, a Slack notification sliding in from the corner, an API token in the terminal above the error you meant to share. None of that was part of your question, and all of it is now in someone else's system.

Note the asymmetry: the model does not read your file metadata (OpenAI states this, and Anthropic's FAQ says "Claude does not parse or receive any metadata from images passed to it"), but the pixels carry everything visible. The invisible EXIF you worried about is ignored; the visible customer name is not.

On retention, read the policy for the tier you are actually on. OpenAI's File Uploads FAQ says files are "saved in your account up to the retention period of the corresponding chat" and are removed within 30 days of deletion, with stated exceptions. Google's Gemini Apps Privacy Hub is blunter: "Please don’t enter confidential information that you wouldn’t want a reviewer to see or Google to use to improve our services, including machine-learning technologies", and adds that human-reviewed chats "are not deleted when you delete your activity. Instead, they are retained for up to three years" (page dated 10 August 2026, accessed 28 August 2026). The same hub confirms that a shared photo is in scope: with the Keep Activity setting on, "your photo or video is used to improve Google services with the help of human reviewers."

What do vision models still get wrong in 2026?

Roughly what they got wrong two years ago, which is why the vendor limitation pages repay a full read.

Both OpenAI and Anthropic publish honest lists, and the overlap is instructive. Non-Latin scripts perform worse. Rotated text gets misread. Small text needs enlarging. Counting is approximate. Panoramic and fisheye images confuse the model, in OpenAI's words: "The model struggles with panoramic and fisheye images." Precise spatial localisation is unreliable. And both vendors carve out medical imaging explicitly, with Anthropic noting that Claude "is not designed to interpret complex diagnostic scans such as CTs or MRIs" and OpenAI saying the model is not suitable for interpreting specialized medical images like CT scans.

None of that makes vision input unreliable in general. It makes the failure silent, which is a different and more manageable problem: you handle it with a verification step rather than by avoiding the tool. If you want the wider habit of building checks into prompts rather than trusting first answers, that is the argument in advanced ChatGPT prompting, and the pre-send version lives in our prompt hygiene checklist. The reason a wrong reading feels so authoritative is the same reason a wrong fact does, which we covered in why ChatGPT makes things up.

One habit is worth adopting immediately, and OpenAI recommends it directly: annotate before you upload. Its ChatGPT FAQ suggests that "To draw attention to specific areas, consider using a photo edit markup tool on your image before uploading." A red circle around the field you mean is a cheaper instruction than three sentences describing where it is. Just remember the redaction rule above when you reach for that same tool.

The short version

Attach less, say more. Name what the image is, name the region, name the output, ask for a transcription before an interpretation, and check the numbers yourself. One image per precise question. Crop before you upload, both because it is more accurate and because the uncropped version says more about you than you intended.

If writing that structure every time is the part that wears you down, that is what we build. Prompt Architects turns a rough instruction into a fully specified one, including the transcribe-first and say-what-you-cannot-see clauses that make image prompts trustworthy. It generates the prompt text only; your image never passes through us, because we do not process images at all. The free plan includes 5 prompt enhancements per day, forever, according to our FAQ page, and the pricing page covers paid tiers.