Gemini Prompt Templates (Multi-Modal Ready)

TL;DR: Gemini prompt templates are worth writing separately from ChatGPT ones for one reason: what you can put in. Organise them by input rather than by job — image, PDF, audio, video, corpus, code — and every template that extracts should be forced to quote its source span and mark what it cannot determine.

What is a Gemini prompt template, and why is it different?

A Gemini prompt template is a reusable instruction with slots, aimed at a model whose defining feature is the range of things you can attach to it. Google's model page for gemini-3.7-flash lists its supported inputs as "Text, Image, Video, Audio, and PDF" with a single output type, text, and an input token limit of 1,048,576 (Gemini 3.7 Flash, accessed 29 August 2026).

That is why most "50 Gemini prompts" listicles are useless. They are text-only prompts with a brand name swapped in. The templates that earn their place are the ones shaped around a file.

There is a second reason to write them separately, and it catches people out constantly: the Gemini app and the Gemini API are different products with different published limits. Everything below is labelled per surface, and where a surface publishes nothing, it says so rather than borrowing the other one's number.

Which inputs does Gemini accept, and on which surface?

Here is what Google publishes, checked at its own documentation on 29 August 2026. The left column is the Gemini API at ai.google.dev; the right is the consumer app at gemini.google.com, documented in the Gemini Apps Help Center.

The API numbers come from Google's image understanding, document understanding, audio understanding, video understanding and Files API guides. The app numbers come from Upload and analyze files in Gemini Apps and Gemini Apps limits and upgrades.

Two of those rows deserve a sentence each. The API guide states plainly that "Gemini models support a maximum of 3,600 image files per request" — a number the app never mentions, because the app caps you at ten files of any kind. And the app's context window is plan-gated: Google's own table reads 32k tokens without an AI plan, 128k on AI Plus, and 1 million on AI Pro and AI Ultra. A free-tier user pasting a long report is designing prompts for 32k tokens, not a million.

Why must every extraction template ask for the source span?

This is the part most template libraries skip, and it is the part that matters.

When Gemini reads a PDF page, a chart, a contract or an audio file, it is not querying a database. Google's document guide describes the mechanism honestly: Gemini processes documents "using native vision", and each page is tokenised as an image at 258 tokens. That is extraction and inference over pixels, not a lookup. The model can misread a figure in a bar chart, invert a clause in a contract, or mishear a proper noun in audio — and report the result with exactly the same confidence it uses when it is right.

There is no prompt that eliminates this. There is a prompt shape that makes it visible:

1. Demand the source span. Every extracted value comes with the quoted text or the page number it came from.
2. Demand a location. Page number for documents, MM:SS for audio and video, region description for images.
3. Forbid gap-filling. Require an explicit NOT_DETERMINABLE marker rather than a plausible guess.
4. Separate reading from reasoning. Ask for the extraction first, the interpretation second, in two labelled blocks.

Say the quiet part out loud to whoever consumes the output: a number pulled from a PDF has to be checked against the PDF. The template's job is to make that check take ten seconds instead of ten minutes, by telling you exactly which page to open.

Every extraction template below carries some version of this block. Keep it when you adapt them.

Gemini prompt templates by what you feed in

Twenty-nine templates, grouped by input. Square brackets are slots. Everything is plain text you can paste into gemini.google.com or send as the text part of an API request, except where labelled as depending on an API tool.

Text in, text out

1. Constrained rewrite

Rewrite the text below for [AUDIENCE].

Constraints:
- Target length: [N] words, hard cap.
- Reading level: [LEVEL].
- Keep every factual claim unchanged. If a claim is ambiguous, keep the original wording verbatim rather than clarifying it.
- Do not add examples, statistics or transitions that are not in the source.

Return only the rewritten text.

TEXT:
[PASTE]

2. Adversarial review

You are reviewing the argument below for [PURPOSE].

Produce three labelled sections:
1. STRONGEST OBJECTION — the single most damaging counter-argument, stated as its best version.
2. UNSUPPORTED CLAIMS — every assertion made without evidence, quoted verbatim.
3. WHAT WOULD CHANGE MY MIND — the specific evidence that would settle it.

Do not summarise the argument back to me. Do not soften the objection.

ARGUMENT:
[PASTE]

3. Decision brief

Turn the notes below into a one-page decision brief for [DECISION_MAKER].

Sections, in order: Decision required · Options (max [N]) · What we know · What we do not know · Recommendation · Reversal cost.

Rules:
- "What we do not know" must not be empty. If the notes cover everything, say which assumptions are load-bearing.
- Every number keeps the unit and the date it was measured.

NOTES:
[PASTE]

Image in, analysis out

Gemini's image handling has a documented quirk: the image understanding guide says "When using a single image with text, place the text prompt before the image in the input array." That is the opposite of its advice for documents and video. Our guide to prompting with images, screenshots and diagrams covers framing and cropping across models; below stays on what Gemini rewards.

4. Chart read with mandatory span

Read the chart in the attached image.

Return a table with columns: SERIES | X_VALUE | Y_VALUE | READ_FROM.
READ_FROM must say where in the image you took the value from — an axis label, a printed data label, or "estimated from bar height".

Rules:
- If a value is not printed on the chart, mark READ_FROM as "estimated" and give a range, not a point.
- If the axis has no units, write NOT_DETERMINABLE. Do not infer units from the title.
- After the table, list anything in the image you could not read.

5. Screenshot to reproduction steps

The image is a screenshot of [APP/PAGE] showing [SYMPTOM].

Return:
1. VISIBLE STATE — only what is literally on screen, quoted where text is legible.
2. LIKELY CAUSE — ranked, with the visual evidence for each.
3. WHAT I CANNOT SEE — what is off-screen or too small to read.

Do not guess at hidden configuration. Section 3 must not be empty.

6. Document photo to structured fields

Extract the following fields from the attached photo of a [DOCUMENT_TYPE]:
[FIELD_1], [FIELD_2], [FIELD_3].

For each field return: value | verbatim quoted text you read it from | confidence (high/low).
Mark confidence low for anything handwritten, rotated, cropped or partially obscured.
If a field is absent, return NOT_PRESENT. Never infer a value from another field.

7. Design mockup to build spec

The image is a UI mockup for [SCREEN].

Produce a build spec: layout regions, component inventory, text content quoted exactly as shown, and states you can infer are needed.

Rules:
- Quote all visible copy character for character, including capitalisation.
- Colours: describe them, do not name hex values you cannot read.
- List every interaction the mockup implies but does not show.

Document or PDF in

Google's document guide contains a limit and a warning worth internalising. The limit: "Gemini supports PDF files up to 50MB or 1000 pages", applying to inline data and Files API uploads alike, on the API. The warning: "document vision only meaningfully understands PDFs" — pass a .docx or .html and it is extracted as pure text, with charts, layout and formatting gone. It also inverts the image advice, saying "If using a single page, place the text prompt after the page."

8. Contract clause extraction

Extract the following from the attached agreement:
[CLAUSE_TYPE_1], [CLAUSE_TYPE_2], [CLAUSE_TYPE_3].

For each, return:
- CLAUSE: the exact quoted text, no paraphrase.
- PAGE: the page number it appears on.
- PLAIN READING: one sentence.
- AMBIGUITY: what a counterparty could argue it means instead. Write NONE only if you genuinely see none.

If a clause type is absent from the document, return ABSENT. Do not construct one from related language.

9. Financial figure extraction

From the attached [REPORT_TYPE], extract every figure for [METRIC].

Table columns: PERIOD | VALUE | UNIT | PAGE | QUOTED_SOURCE_LINE.
QUOTED_SOURCE_LINE is the verbatim line of the document the number came from.

Rules:
- Do not restate figures in a different unit or currency.
- If a figure appears in a chart rather than text, say so in QUOTED_SOURCE_LINE.
- If two pages disagree, return both rows and add a CONFLICT note. Do not pick a winner.

10. Long-document question with citations

Answer this question using only the attached document: [QUESTION]

Format:
ANSWER: [2–4 sentences]
EVIDENCE: 2–5 verbatim quotes, each with its page number.
NOT COVERED: what the question asks that this document does not answer.

If the document does not answer the question, say so in ANSWER and leave EVIDENCE empty. Do not use outside knowledge.

11. Cross-document conflict check

Compare the attached documents: [DOC_A] and [DOC_B].

Return a table: TOPIC | WHAT DOC_A SAYS (quoted + page) | WHAT DOC_B SAYS (quoted + page) | CONFLICT? (yes/no/partial).

List only topics both documents actually address. Do not resolve conflicts, do not decide which document is newer, and do not smooth wording differences into agreement.

Audio in

Google's audio guide publishes the numbers that shape these templates: 32 tokens per second of audio, a maximum length of "9.5 hours of audio per prompt", downsampling to 16 Kbps, and multi-channel audio "combined to single channel" on the API. That last one matters — if your recording separates speakers by channel, that separation is gone before the model sees it, so diarisation is inference, not metadata. Reference specific sections with MM:SS, which is the format the guide uses throughout.

12. Meeting transcript to decisions

From the attached recording, extract only decisions and commitments.

Table: TIMESTAMP (MM:SS) | WHO (as named in audio, or SPEAKER_N) | DECISION OR COMMITMENT | QUOTED WORDS.

Rules:
- Speaker names come only from the audio. If nobody is named, use SPEAKER_1, SPEAKER_2.
- Discussion without a decision is excluded.
- If a name is unclear, write UNCLEAR_NAME rather than the closest common name.

13. Interview segment analysis

Analyse the section from [START_MMSS] to [END_MMSS] of the attached audio.

Return: what was asked, what was answered, what was asked but not answered, and any point where the speaker changed position.

Quote the exact words for every claim, with a timestamp. Do not characterise tone unless the words support it.

14. Call to structured summary

Summarise the attached [CALL_TYPE] for [AUDIENCE].

Sections: Context · What the other party wants · What we committed to · Open questions · Next action and owner.

Every line carries a MM:SS timestamp. If a section has nothing in the audio, write NONE — do not infer it from the rest of the call.

Video in

The video guide is specific about how video reaches the model. Frames are sampled at 1 FPS, audio is processed at 1Kbps single channel, and timestamps are added every second. It warns that "fast action sequences might lose detail due to the 1 FPS sampling rate", and its best-practice list says to "Use only one video per prompt request for optimal results" even though Gemini 2.5 and later accept up to 10. YouTube URLs can be passed directly on the API; only public videos, and the free tier is capped at 8 hours of YouTube video per day.

15. Timestamped video breakdown

Break down the attached video.

Table: TIMESTAMP (MM:SS) | WHAT IS ON SCREEN | WHAT IS SAID | WHY IT MATTERS FOR [GOAL].

Rules:
- One row per distinct beat, not per second.
- Separate visual from audio. If something is said but not shown, leave the visual column blank rather than inventing it.
- Note anywhere motion was too fast to read reliably.

16. Demo video to written procedure

The video shows someone performing [TASK] in [TOOL].

Write the procedure as numbered steps someone could follow without the video.

For each step: the action, the exact on-screen element they clicked or typed into, and the timestamp.
If a step happens off-screen or is cut, write STEP_NOT_SHOWN. Do not fill the gap from general knowledge of [TOOL].

17. Video content audit

Audit the attached video against this checklist: [CHECKLIST_ITEMS].

Return: ITEM | PRESENT? (yes/no/partial) | TIMESTAMP | QUOTED OR DESCRIBED EVIDENCE.

Mark "partial" only when you can point to a specific timestamp and say what is missing. Do not mark an item present because the video implies it.

A large corpus in

Long context is Gemini's headline capability and its most over-claimed one. The section below covers what that window does and does not buy you.

18. Corpus-wide question with citations

Using only the attached [N] documents, answer: [QUESTION]

Format:
ANSWER
EVIDENCE: 3–8 verbatim quotes, each labelled with the source filename and page.
DISAGREEMENT: any place the sources contradict each other, both quoted.
GAPS: what the question needs that no source covers.

Put nothing in ANSWER that is not supported by an EVIDENCE quote.

19. Chunked extraction pass

This is part [K] of [N] of a larger corpus.

Extract every instance of [TARGET] you find in THIS part only.
Table: ITEM | VERBATIM QUOTE | SOURCE | LOCATION.

Do not summarise. Do not deduplicate against parts you have not seen. Do not carry conclusions forward. Output the table and nothing else.

20. Corpus inventory before analysis

Before answering anything, inventory the attached corpus.

For each document: filename, apparent type, date if stated, length, and one sentence on what it covers.
Then list: which documents are relevant to [QUESTION], and which are not, with a reason.

Do not answer [QUESTION] yet. Wait for my confirmation of the inventory.

Structured output

Google moved this surface, and most articles still show the old shape. The current structured outputs guide documents a POST to https://generativelanguage.googleapis.com/v1beta/interactions carrying a response_format object with type, mime_type and schema. The generationConfig.responseSchema form appears nowhere on that page as of 29 August 2026. Google's own limitations note that "Not all JSON Schema features are supported" and that "Very large or deeply nested schemas may be rejected". If you want the general craft of getting machine-readable answers, our JSON prompt generator guide covers it across models.

21. Extraction to a fixed schema (API: pair with response_format)

Extract [ENTITY_TYPE] records from the attached [SOURCE].

Every record must include a `source_quote` field holding the verbatim text the record came from, and a `location` field holding the page number or MM:SS timestamp.
Where a field is not present in the source, use null. Never infer a value to satisfy the schema.
Return an empty array if the source contains none.

22. Classification with a forced abstain option

Classify each item below into exactly one of: [CATEGORY_LIST], or "unclear".

For each item return: id, category, confidence (high/medium/low), and the phrase that decided it.
Use "unclear" whenever two categories are equally defensible. A low-confidence forced choice is worse than an abstain.

ITEMS:
[PASTE]

23. Table normalisation

Normalise the attached [TABLE_SOURCE] into a flat structure.

Columns: [COLUMN_LIST].
Rules:
- Preserve original values exactly. Do not convert units, round, or reformat dates.
- Add a `raw_source` column carrying the original cell text for any value you had to interpret.
- Rows you cannot map get a `mapping_status` of "unmapped" and are still returned.

Grounded and search-backed

Grounding with Google Search is an API tool, enabled with tools = [{"type": "google_search"}], not something you type into a chat box. Google's grounding guide says the model "automatically generates one or multiple search queries" when it judges search would help, and returns url_citation annotations linking text segments to sources. The separate URL context tool takes URLs you supply — up to 20 per request, 34MB per URL, and explicitly not YouTube videos, paywalled pages or Google Workspace files. Both accessed 29 August 2026.

24. Grounded fact check (API: enable google_search)

Check each claim below against current sources.

Table: CLAIM | VERDICT (supported / contradicted / no source found) | SOURCE URL | QUOTED SUPPORTING LINE | DATE OF SOURCE.

Rules:
- "No source found" is a valid and expected verdict. Do not stretch a partial match into "supported".
- Prefer the primary source over any article about it. If you only found secondary coverage, say so.

CLAIMS:
[PASTE]

25. Named-source comparison (API: enable url_context)

Read these URLs: [URL_1], [URL_2], [URL_3].

For [TOPIC], report what each page actually says, quoted, with the URL.
Then list every point where they disagree, both sides quoted.

Use nothing outside these three pages. If a page did not load or did not cover [TOPIC], say which and stop there.

26. Freshness check on a stale claim (API: enable google_search)

This claim was true as of [DATE]: [CLAIM]

Determine whether it still holds. Return:
CURRENT STATUS · WHAT CHANGED · DATE OF THE CHANGE · SOURCE URL AND QUOTED LINE · CONFIDENCE.

If you cannot find a source dated after [DATE], say the claim is unverified as of today rather than assuming it still holds.

Code

Gemini's code execution tool runs Python only, with a maximum runtime of 30 seconds, up to 5 retries after an error, and matplotlib as the only supported graph renderer. It "works best with text and CSV files". The templates below are plain prompting; only the third assumes the tool.

27. Unfamiliar code walkthrough

Explain what the code below does, for someone who knows [LANGUAGE] but not this codebase.

Sections: What it does · How data flows through it · What it assumes about its callers · What breaks it.

Quote the specific lines behind each claim. Where behaviour depends on something not in this snippet, say so instead of guessing.

CODE:
[PASTE]

28. Review with a stated risk bar

Review this diff for [RISK_TYPE] only. Ignore style.

For each finding: severity, the exact lines, why it is a problem, and the smallest change that fixes it.
If you find nothing at this severity, say so and stop. Do not pad the review with lower-severity observations.

DIFF:
[PASTE]

29. Data file analysis (API: enable code execution)

Analyse the attached CSV to answer: [QUESTION]

Write and run the code. Then return:
1. The answer.
2. The code you ran.
3. The row count you actually processed, and any rows dropped, with the reason.

If the file's structure does not support the question, say so instead of reshaping the data to fit.

Does a 1M context window mean Gemini remembers all of it?

No, and Google says so on its own page.

The long context guide (accessed 29 August 2026) is direct about where the capability thins out. It describes strong performance on single-needle retrieval evals, then adds that in cases with multiple needles "the model does not perform with the same accuracy", and that "Performance can vary to a wide degree depending on the context." The consumer help page makes the same point in plainer language, warning that an oversized upload can produce a response that "misses connections or details throughout the content", and that this "is most relevant for prompts that require attention to many details scattered throughout large file(s)".

I am not going to dress that up with a mechanism. I have not read a paper I can cite for why it happens, and inventing one would be exactly the kind of confident-sounding filler this post is arguing against. What I can tell you is what to do about it, which is three things:

1. Ask for citations to the source, always. If the answer must carry a page number and a quote, a missed detail becomes a visible gap rather than a smooth paragraph.
2. Chunk the task, not just the text. Template 19 exists for this: one extraction pass per chunk, no summarising, no carrying conclusions forward, then a merge pass over the extraction tables.
3. Ask one question at a time. Google's guide frames the cost side of this bluntly — for 100 pieces of information at high accuracy "you would likely need to send 100 requests". That is expensive, and it is also the honest shape of the problem.

And note what the app's plan table does to all of this. On a free Gemini account the window is 32k tokens, not a million. Half the long-context advice circulating online is describing a product tier the reader is not on.

Where do you put the prompt: before or after the file?

Google gives a different answer per modality, deliberately, and each one is easy to miss because it lives at the bottom of a different page.

• Image: "When using a single image with text, place the text prompt before the image in the input array." — image understanding guide.
• PDF page: "If using a single page, place the text prompt after the page." — document understanding guide.
• Video: "If combining text and a single video, place the text prompt after the video part in the input array." — video understanding guide.
• Long context generally: the long context FAQ says performance "will be better if you put your query / question at the end of the prompt (after all the other context)."

So the image case is the odd one out. In the chat app you have less control over ordering than the API's input array gives you, but the practical version still holds: type your instruction before attaching a single image, and after attaching a document or a video.

What does Google not publish for the Gemini app?

Worth stating explicitly, because the absence is what most articles paper over with an API number.

As of 29 August 2026, the Gemini Apps Help Center does not publish: a PDF page limit, an enumerated list of supported file types (it says only that "Gemini Apps support most file types"), a per-image resolution or tiling figure, an image count separate from the 10-file cap, or any token cost per image, page or second of audio. It does publish a 100MB per-file ceiling, 2GB for video, the 10-file cap, the 5,000-file / 100MB limit for a code folder or GitHub repository, ZIP rules, and the plan-gated context window table.

The Gemini API publishes all of the missing ones and more. That asymmetry is the single most important thing to hold in your head when you read anyone's Gemini limits table, including tables that look authoritative.

How do you stop these templates from going stale?

Multi-modal limits rot faster than anything else in prompting. Two model facts checked for this post were already a version behind what we had on file: Google's models page now lists gemini-3.1-pro-preview under Preview while gemini-3.7-flash sits under Stable as "Our latest and most capable Flash model", and Gemini Omni Flash's endpoint reads gemini-omni-1.1-flash.

Three habits keep a template library honest:

• Date the limit, not just the template. Every number here carries an access date because every one of them can move next month.
• Store the source URL beside the prompt. When output goes strange, the first question is whether a limit changed.
• Re-check per surface. The app and the API drift independently, so a change to one tells you nothing about the other.

For keeping one library working across several tools, see syncing prompts across platforms.

The short version

Gemini prompt templates are organised by input, not by job, because the input is the whole reason to write them separately. Feed it an image and put your instruction first; feed it a PDF or a video and put your instruction last. Every template that extracts must return the quoted source span and a page number or timestamp, and must be allowed to say it cannot tell. The million-token window is real and it is also plan-gated in the app and imperfect at multi-fact recall everywhere — Google says both. Check the number against the file.