Citations and showing sources

Why this matters #

An AI answer without sources asks users to take it on faith. Sometimes that’s fine: nobody needs a citation for a suggested subject line. But for anything users will act on, repeat to others or rely on later, “where did this come from?” is the first question they’ll ask.

Citations answer it. They let users verify a surprising claim in seconds, they make wrong answers visible instead of hidden, and they shift trust from the model to the source, which is where it belongs. This article covers when to show sources, the patterns that work, and how to get reliable citations from the API.

Why sources matter #

Showing sources does several jobs at once:

• Verification. Users can check the claim that matters to them without re-reading everything.
• Catching mistakes. When a cited passage doesn’t support the claim, the error is obvious. Without citations, the same error looks exactly like a correct answer.
• Trust calibration. Users learn when to rely on the feature and when to check, instead of trusting everything or nothing.
• Accountability. In regulated or high-stakes settings, being able to show what an answer was based on is often a requirement.

There’s also a benefit for you: answers grounded in sources you provided are far less likely to contain invented facts, because the model is working from text in front of it rather than from memory. See what LLMs are good and bad at.

Citation patterns #

How much of that to show depends on the stakes:

Some practical rules:

• Cite claims, not paragraphs. A marker after each specific claim is more useful than one list at the end.
• Quote exactly. Show the passage the claim relies on, word for word, so users don’t need to open the document.
• Link to the right place. Opening a 40-page document at page one defeats the purpose.
• Show uncited claims honestly. If part of an answer has no source, don’t decorate it with one. A clear difference between cited and uncited text is itself useful information.

Getting citations from the API #

You could ask a model to “include sources” in its text, but then the model writes the references itself, and nothing guarantees they’re accurate. Claude’s citations feature (opens in a new tab) is more reliable: you pass documents with citations enabled, and the response comes back split into text blocks, each carrying structured citations that point to the exact passage in your documents.

This function answers a question from a set of documents and returns the answer with numbered markers and the quoted passages behind them:

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

export interface Source {
  title: string;
  url: string;
  text: string;
}

export type CitedAnswer =
  | { status: 'answered'; text: string; citations: { n: number; title: string; url: string; quote: string }[] }
  | { status: 'declined' }
  | { status: 'incomplete'; reason: string };

export async function answerWithCitations(question: string, sources: Source[]): Promise<CitedAnswer> {
  const response = await client.messages.create({
    model: 'claude-opus-5-5',
    max_tokens: 4096,
    output_config: { effort: 'low' },
    system: 'Answer using only the provided documents. If they do not contain the answer, say so plainly instead of guessing.',
    messages: [
      {
        role: 'user',
        content: [
          ...sources.map(
            (s): Anthropic.DocumentBlockParam => ({
              type: 'document',
              source: { type: 'text', media_type: 'text/plain', data: s.text },
              title: s.title,
              citations: { enabled: true },
            }),
          ),
          { type: 'text', text: question },
        ],
      },
    ],
  });

  if (response.stop_reason === 'refusal') return { status: 'declined' };
  // A cut-off answer may have lost the claims, or the citations, that matter most. Don't show it as complete.
  if (response.stop_reason !== 'end_turn') return { status: 'incomplete', reason: String(response.stop_reason) };

  let text = '';
  const citations: { n: number; title: string; url: string; quote: string }[] = [];
  const numberFor = new Map<string, number>();

  for (const block of response.content) {
    if (block.type !== 'text') continue;
    text += block.text;
    for (const citation of block.citations ?? []) {
      // Plain-text documents produce character-range citations.
      if (citation.type !== 'char_location') continue;
      const source = sources[citation.document_index];
      if (!source) continue;
      // Reuse the same number when two claims cite the same passage.
      const key = `${citation.document_index}:${citation.start_char_index}`;
      let n = numberFor.get(key);
      if (n === undefined) {
        n = citations.length + 1;
        numberFor.set(key, n);
        citations.push({ n, title: source.title, url: source.url, quote: citation.cited_text });
      }
      text += ` [${n}]`;
    }
  }

  return { status: 'answered', text, citations };
}

Your interface then renders text with the markers as links, and each entry in citations as a source card with its quote. Things to notice:

• Citations are data, not text. Each one points to a real document by index and to an exact character range, and includes the quoted passage. Your code builds the markers; the model never types a reference.
• The system prompt allows “not in the documents”. Without that instruction, a model may stretch a weak source to answer anyway.
• Unfinished answers aren’t shown as complete. Refusals and truncated answers get their own states.
• Citations don’t combine with structured outputs. If you need JSON as well, make a separate call or extract citations first. The citations docs (opens in a new tab) list the supported document types, including PDFs, which cite by page.

Where the documents come from is a separate problem: a small set can be passed whole; a large one needs retrieval first. Project 2 combines both.

When there is no good source #

The hardest citation case is when the answer isn’t in the sources. The right behavior is to say so, clearly and helpfully:

• Say what’s missing. “The handbook doesn’t cover remote work outside your country” is more useful than a generic “I don’t know”.
• Offer the next step. Link to the closest relevant section, suggest who to ask, or offer to search more widely.
• Never fill the gap from the model’s memory without saying so. If you allow answers beyond the sources, label them clearly as uncited.

Measure this behavior in your evals: include questions whose answers aren’t in the documents, and check that the feature declines to answer rather than inventing one. That single category of eval case catches many of the most damaging failures. Communicating confidence and uncertainty covers abstaining in more depth.

Common mistakes #

Try it #

Check your understanding #

Key takeaways #