Skip to content
The Status Code

418 I'm a teapot

📄 RFC 9110 📁 4xx Client Error

What is HTTP 418 I’m a teapot?

418 I'm a teapot
Back in 1998, some computer scientists made a funny joke. They wrote instruction...
HTTP 418 I'm a teapot status code illustration

Explain Like I’m 3

Imagine you have a teapot that’s really good at making tea. You ask it “Please make me coffee!” But the teapot says “I’m a teapot! I can only make tea, not coffee!” That’s what 418 means - you asked for something, but you asked the wrong thing! It’s like asking your teddy bear to fly - teddy bears can’t fly because they’re teddy bears, and teapots can’t make coffee because they’re teapots!

Example: Asking your toy train to drive on the road like a car. The train says “I’m a train! I only work on train tracks, not roads!”

Explain Like I’m 5

Back in 1998, some computer scientists made a funny joke. They wrote instructions for controlling coffee pots over the internet (like turning them on from your computer!). They said if you try to make a teapot brew coffee, it should say “418 I’m a teapot” - because teapots can’t make coffee, only tea! Even though it started as an April Fools’ joke, people loved it so much that it’s now an official internet code. When you see 418, it means “This isn’t the right kind of server for what you’re asking!” It’s the internet’s way of being silly!

Example: Like asking Alexa to make you a sandwich. Alexa would say “I’m a voice assistant, not a kitchen robot!” That’s basically what 418 means.

Jr. Developer

418 I’m a teapot is a real HTTP status code that started as an April Fools’ joke and became internet history. It was defined in RFC 2324 (1998) as part of the “Hyper Text Coffee Pot Control Protocol” (HTCPCP), a parody protocol for controlling coffee makers over HTTP.

The joke: “Any attempt to brew coffee with a teapot should result in the error code ‘418 I’m a teapot’. The resulting entity body MAY be short and stout.”

Why it matters: In 2017, there was an attempt to remove 418 from official specifications. The “Save 418” movement (led by 15-year-old developer Shane Brunswick at save418.com) convinced major frameworks (Node.js, Go, Python, ASP.NET) to keep it. RFC 9110 (2022) officially reserved 418, ensuring it can’t be used for real error semantics.

Real-world usage:

  • Easter eggs in APIs (Google has one at google.com/teapot)
  • Placeholder for “this operation isn’t supported”
  • Humorous error responses
  • Rate limiting alternative (though 429 is better)

When NOT to use it: Don’t use 418 for actual production errors - use proper status codes (404, 405, 501, etc.). 418 is for fun, not serious error handling. It’s internet culture, not a production tool.

Code Example

// Express.js: Implementing the teapot Easter egg
const express = require('express');
const app = express();


// The classic teapot endpoint
app.get('/tea', (req, res) => {
  res.status(200).json({
    message: 'Here is your tea!',
    type: 'Earl Grey',
    temperature: 'Hot'
  });
});


// Attempt to brew coffee with a teapot
app.get('/coffee', (req, res) => {
  res.status(418).json({
    error: "I'm a teapot",
    message: 'This server is a teapot, not a coffee pot',
    short_and_stout: true,
    tip_me_over_and_pour_me_out: true,
    alternatives: [
      { beverage: 'tea', endpoint: '/tea' },
      { beverage: 'hot chocolate', endpoint: '/hot-chocolate' }
    ]
  });
});


// Google-style Easter egg
app.get('/teapot', (req, res) => {
  res.status(418).send(`
    <html>
      <head><title>418 I'm a teapot</title></head>
      <body style="font-family: sans-serif; text-align: center; padding: 50px;">
        <h1>418</h1>
        <h2>🫖 I'm a teapot</h2>
        <p>The requested entity body is short and stout.</p>
        <p>Tip me over and pour me out.</p>
        <br>
        <small>RFC 2324 Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)</small>
      </body>
    </html>
  `);
});


// Fun rate limiting using 418 (though 429 is more appropriate)
let requestCount = 0;
app.get('/api/data', (req, res) => {
  requestCount++;


  if (requestCount > 100) {
    return res.status(418).json({
      error: "I'm a teapot",
      message: "You've asked for too much coffee. I'm just a teapot!",
      hint: 'Maybe try again later, or ask for tea instead?'
    });
  }


  res.json({ data: 'your data here' });
});

Crash Course

HTTP status code 418 is unique in internet history - a joke that became so beloved it was formally reserved in the official HTTP specification. Understanding 418 requires understanding both its technical origins and its cultural significance.

Historical Timeline:

1998 (April 1): Larry Masinter publishes RFC 2324, introducing HTCPCP (Hyper Text Coffee Pot Control Protocol). The RFC is satire, demonstrating how HTTP was being inappropriately extended for non-web purposes. Section 2.3.2 defines:

“Any attempt to brew coffee with a teapot should result in the error code ‘418 I’m a teapot’. The resulting entity body MAY be short and stout.”

2014 (April 1): RFC 7168 extends HTCPCP to support tea brewing (HTCPCP-TEA).

2017 (August): Mark Nottingham (IETF HTTPBIS Working Group chairman) proposes removing 418 from Node.js, arguing it was never part of the HTTP standard. He requests removal from Go, Python Requests, and ASP.NET.

2017 (August 5): Shane Brunswick (age 15) creates save418.com to preserve the status code. The movement goes viral.

2017 (days later): Node.js, Go, Python, and ASP.NET decide to keep 418. Overwhelming support convinces Nottingham to reverse course.

2022 (June): RFC 9110 (HTTP Semantics) officially reserves 418: “[418] was defined in the Section 2.3.2 of [RFC2324], and therefore cannot be assigned any non-joke semantics for the foreseeable future.”

Technical Context:

RFC 2324’s satire targeted protocol proliferation - the tendency to use HTTP for everything. HTCPCP included methods like BREW, POST, GET, PROPFIND, and WHEN, with headers like Accept-Additions (Sugar, Cream, Whisky).

While obviously humorous, the RFC made a serious point: not everything needs to run on HTTP.

Modern Usage:

  1. Easter Eggs: Google.com/teapot returns 418 with an animated teapot
  2. API Humor: Fun responses for unsupported operations
  3. Rate Limiting: Some APIs use 418 instead of 429 (though 429 is correct)
  4. **Testin…

Code Example

// Comprehensive 418 implementation with HTCPCP references
const express = require('express');
const app = express();


// HTCPCP-compliant teapot server
class TeapotServer {
  constructor() {
    this.teaTypes = ['Earl Grey', 'Green Tea', 'Chamomile', 'Oolong'];
    this.waterTemp = 100; // Celsius
    this.isTeapot = true;
  }


  canBrewCoffee() {
    return false; // Teapots can't brew coffee!
  }


  brew(beverage) {
    if (beverage.toLowerCase() === 'coffee') {
      return {
        statusCode: 418,
        error: "I'm a teapot",
        message: 'The requested entity body is short and stout',
        rfc: 'RFC 2324 Section 2.3.2',
        tip_me_over_and_pour_me_out: true
      };
    }


    if (beverage.toLowerCase() === 'tea') {
      return {
        statusCode: 200,
        beverage: beverage,
        temperature: this.waterTemp,
        message: 'Tea is ready!'
      };
    }


    return {
      statusCode: 501,
      error: 'Not Implemented',
      message: `I don't know how to brew ${beverage}`
    };
  }
}


const teapot = new TeapotServer();


// HTCPCP BREW method (extended HTTP)
app.brew = function(path, ...handlers) {
  // Custom HTTP method for brewing
  this.all(path, (req, res, next) => {
    if (req.method === 'BREW') {
      req.brewing = true;
    }
    next();
  }, ...handlers);
};


// Coffee brewing endpoint
app.brew('/brew/coffee', (req, res) => {
  const result = teapot.brew('coffee');


  res.status(result.statusCode)
    .set('Server', 'HTCPCP/1.0 Teapot')
    .json(result);
});


// Tea brewing endpoint
app.brew('/brew/tea', (req, res) => {
  const result = teapot.brew('tea');


  res.status(result.statusCode)
    .set('Server', 'HTCPCP-TEA/1.0 Teapot')
    .json(result);
});


// Accept-Additions header support (HTCPCP extension)
app.post('/brew/tea', (req, res) => {
  const additions = req.get('Accept-Additions');
  const supportedAdditions = ['Cream', 'Sugar', 'Honey', 'Milk'];


  if (additions) {
    const requested = additions.split(',').map(a => a.trim());
    const unsupported = requested.filter(a => !supportedAdditions.includes(a));


    if (unsupported.length > 0) {
      return res.status(418).json({
        error: "I'm a teapot",
        message: `This teapot doesn't support additions: ${unsupported.join(', ')}`,
        supported_additions: supportedAdditions
      });
    }
  }


  res.status(200).json({
    message: 'Tea brewed successfully',
    additions: additions ? additions.split(',').map(a => ...

Deep Dive

HTTP status code 418 represents a unique intersection of technical satire, internet culture, and protocol design philosophy. Its journey from April Fools’ joke to formally reserved status code illustrates how informal norms can influence formal standards.

RFC 2324: The Original Satire (1998)

Larry Masinter’s RFC 2324 introduced HTCPCP (Hyper Text Coffee Pot Control Protocol), ostensibly for “controlling, monitoring, and diagnosing coffee pots.” The RFC’s stated purpose:

“This has a serious purpose – it identifies many of the ways in which HTTP has been extended inappropriately.”

Protocol Design Critique:

RFC 2324 satirized several HTTP extension anti-patterns:

  1. Method Proliferation: Introduced BREW, WHEN, PROPFIND methods to mock arbitrary HTTP method creation
  2. Semantic Overloading: “Safe” headers (Safe-Response-Type) that contradict HTTP’s semantic guarantees
  3. Application-Layer Misuse: Using HTTP for device control rather than document transfer
  4. Header Bloat: Accept-Additions: (Cream, Sugar, Syrup, Alcohol, Caffeine) mocking increasingly specific content negotiation

The 418 Definition:

Section 2.3.2 states: “Any attempt to brew coffee with a teapot should result in the error code ‘418 I’m a teapot’. The resulting entity body MAY be short and stout.”

This seemingly nonsensical requirement actually demonstrates proper error semantics: return an error when a server cannot fulfill a request due to fundamental capability limitations.

RFC 7168: HTCPCP-TEA Extension (2014)

Sixteen years later, Imre Patyi published RFC 7168, extending HTCPCP to support tea brewing. This meta-satire extended the joke while maintaining technical coherence:

  • Accept-Additions extended with: Milk, Panna, Cinnamon
  • New response codes: 300 Multiple Options (tea vs coffee)
  • Steeping parameter: Controls brew strength

The Controversy (2017)

Mark Nottingham’s proposal to remove 418 raised fundamental questions:

Arguments for removal:

  • 418 was never part of HTTP proper (only in HTCPCP)
  • Confusion between joke and real status codes
  • Semantic pollution of HTTP status code space
  • Sets precedent for non-serious codes

Arguments for preservation (Save 418 movement):

  • Widely deployed in production systems
  • Cultural significance (internet history)
  • Harmless - reserved code range unused otherwise
  • Community consensus for preservation
  • Educational value (teaches HTTP status codes through humor)

**Technical Implications of…

Code Example

// Production-quality 418 implementation with full HTCPCP compliance
const express = require('express');
const app = express();


/**
 * HTCPCP Server Implementation
 * Demonstrates proper 418 usage while maintaining HTTP compliance
 *
 * RFC 2324: https://datatracker.ietf.org/doc/html/rfc2324
 * RFC 7168: https://datatracker.ietf.org/doc/html/rfc7168
 * RFC 9110: https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.19
 */


class HTCPCPServer {
  constructor() {
    this.deviceType = 'teapot'; // Could be 'coffeepot' or 'teapot'
    this.supportedBeverages = {
      teapot: ['tea', 'herbal-tea', 'chai'],
      coffeepot: ['coffee', 'espresso', 'latte']
    };
    this.supportedAdditions = {
      tea: ['Milk', 'Sugar', 'Honey', 'Lemon'],
      coffee: ['Cream', 'Sugar', 'Syrup']
    };
  }


  canBrew(beverage) {
    return this.supportedBeverages[this.deviceType].includes(beverage.toLowerCase());
  }


  get418Response() {
    return {
      statusCode: 418,
      error: "I'm a teapot",
      message: 'The requested entity body is short and stout',
      explanation: `This is a ${this.deviceType}. It cannot brew beverages it doesn't support.`,
      rfc_reference: 'RFC 2324 Section 2.3.2',
      reserved_in: 'RFC 9110 Section 15.5.19',
      historical_note: 'Preserved by the Save 418 Movement (2017)',
      supported_beverages: this.supportedBeverages[this.deviceType],
      learn_more: 'https://save418.com'
    };
  }
}


const htcpcpServer = new HTCPCPServer();


// Custom BREW method implementation
app.use((req, res, next) => {
  // Support custom BREW method
  if (req.headers['x-http-method-override'] === 'BREW') {
    req.method = 'BREW';
  }
  next();
});


// HTCPCP compliant brewing endpoint
app.all('/brew/:beverage', (req, res) => {
  const beverage = req.params.beverage;


  // Check if this device can brew the requested beverage
  if (!htcpcpServer.canBrew(beverage)) {
    const response = htcpcpServer.get418Response();


    return res.status(418)
      .set('Server', 'HTCPCP/1.0')
      .set('X-Teapot', 'true')
      .json(response);
  }


  // Validate Accept-Additions header (HTCPCP extension)
  const additions = req.get('Accept-Additions');
  if (additions) {
    const requested = additions.split(',').map(a => a.trim());
    const beverageType = beverage.includes('tea') ? 'tea' : 'coffee';
    const supported = htcpcpServer.supportedAdditions[beverageType];
    const unsupported = requested.filter(a => !supported.includes(a));


    if (unsupported.length > 0) {
      return res.status(418)
        .set('Server', 'HTCPCP/1.0')
        .json({
          error: "I'm a teapot",
          message: `Unsupported additions requested: ${unsupported.join(', ')}`,
          supported_additions: supported,
          requested_additions: requested
        });
    }
  }


  // Successfully brew
  res.status(200)
    .set('Server', 'HTCPCP/1.0')
    .json({
      beverage: beverage,
      status: 'brewed',
      additions: additions...

Frequently Asked Questions

Is 418 I'm a teapot a real HTTP status code?

Yes! While it originated as an April Fools' joke in RFC 2324 (1998), it was formally reserved in RFC 9110 (2022) due to widespread adoption. Major frameworks like Node.js, Go, Python, and ASP.NET officially support it. However, it's reserved for "non-joke semantics," meaning it should only be used for humor, not actual error conditions.

What is the Hyper Text Coffee Pot Control Protocol (HTCPCP)?

HTCPCP is a parody protocol introduced in RFC 2324 (April 1, 1998) supposedly for controlling coffee pots over HTTP. It was satire by Larry Masinter demonstrating how HTTP was being inappropriately extended for non-web purposes. The protocol includes methods like BREW, headers like Accept-Additions (Cream, Sugar), and of course, status code 418 for teapots that can't brew coffee.

What was the Save 418 Movement?

In 2017, when Mark Nottingham proposed removing 418 from Node.js and other frameworks, 15-year-old developer Shane Brunswick created save418.com to preserve it. The movement went viral, and major tech companies decided to keep 418. This community pressure led to RFC 9110 formally reserving the status code, preventing it from being assigned other meanings. It's a rare case of internet culture influencing technical standards.

Should I use 418 in my production API?

Generally no, unless it's for Easter eggs or humor. Use proper status codes for actual errors: 404 for not found, 405 for wrong method, 501 for not implemented, 429 for rate limiting, etc. 418 is fun for internal tools, developer-facing APIs with a sense of humor, or April Fools' features, but avoid it where clarity is critical (financial, healthcare, public APIs).

Does Google really return 418 for anything?

Yes! Visit google.com/teapot and you'll get a 418 response with an animated tilting teapot. It's Google's tribute to internet culture and the Save 418 Movement. The page returns an actual HTTP 418 status code and includes the RFC 2324 reference. It's one of the most famous Easter eggs in web development.

What does 'short and stout' mean in the 418 response?

It's a reference to the children's nursery rhyme 'I'm a Little Teapot': 'I'm a little teapot, short and stout. Here is my handle, here is my spout. When I get all steamed up, hear me shout, tip me over and pour me out!' RFC 2324 states that 418 response bodies 'MAY be short and stout,' directly referencing the rhyme.

Are there other humorous RFCs like RFC 2324?

Yes! The IETF has a tradition of April Fools' RFCs. Examples: RFC 1149 (IP over Avian Carriers - carrier pigeons), RFC 2549 (IP over Avian Carriers with QoS), RFC 8140 (ASCII Art specification), and RFC 7168 (HTCPCP-TEA extending coffee protocol to tea). But 418 is unique - it's the only joke status code that made it into the official HTTP specification.

Common Causes

  • Developer Easter egg or joke endpoint
  • API response for unsupported beverage brewing (literally)
  • Humorous rate limiting implementation (though 429 is better)
  • April Fools’ Day prank features
  • Testing HTTP client error handling
  • Educational demonstrations of HTTP status codes
  • Fun responses in developer-facing internal tools
  • Deliberate cultural reference to RFC 2324 and Save 418 Movement
  • Google.com/teapot Easter egg
  • Framework/library default implementation (Node.js, Go, etc.)
  • Satire of inappropriate HTTP protocol extensions
  • Response to HTCPCP BREW method for coffee from a teapot

Implementation Guidance

  • Recognize this is a joke status code - don’t treat it as a serious error
  • If you need actual error handling, use proper codes: 404, 405, 501, 429
  • For unsupported operations: use 501 Not Implemented instead
  • For wrong HTTP method: use 405 Method Not Allowed instead
  • For rate limiting: use 429 Too Many Requests instead
  • If encountered on production API: contact developers (they’re having fun)
  • For HTCPCP joke endpoint: request tea instead of coffee
  • Visit google.com/teapot to see the most famous 418 implementation
  • Learn about internet history at save418.com
  • Read RFC 2324 for a good laugh and insight into HTTP protocol design
  • If building API: consider if 418 adds value or just causes confusion
  • Appreciate the cultural significance - it’s preserved internet history!

Related Status Codes

405Method Not Allowed501Not Implemented503Service Unavailable429Too Many Requests

Comments