One short line, held to eight rules.

Try it

This runs the real service against the real models, with the same eight guards. It takes no key, so it is capped tightly and the fields it accepts are the safe subset: no forbid, no custom schema, and {name} is the only token allowed. It also keeps to everyday subjects: a voice or ask that names news events, politics, war, religion, health, money or similar comes back as blocked_topic without reaching a model. Keyed calls are not under that list; forbid is how you set your own.

Do not type anything about a real person here. Send {name} and picture the rest. Demo prompts are not stored, and the tokens are the whole point.

Before you start

There is no sign-up page. Keys are issued by hand, one per application, so write to getmeme@warmhop.com and say what you are building and roughly how often you will call.

A key is shown once, when it is created. Only its hash is stored here, so a lost key cannot be looked up or recovered: ask for it to be rotated and the old one stops working on the next request.

Authentication

Every request carries the key as a bearer token, except the four that take none: /health, /openapi.json, this page and its icon.

Authorization: Bearer gm_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

A missing, unknown, revoked or expired key is 401 invalid_api_key with a WWW-Authenticate header. The four cases are not told apart on purpose.

Create a line

One endpoint, and it knows nothing about what the line is for. There is no /greeting and no /welcome, because the wording belongs to you: you send the voice, getmeme holds it to a shape.

Fields marked * are required. Unknown fields are rejected outright, the body is capped at 16KB, and Content-Type: application/json is required.

A call, in full

curl -sS https://getmeme.warmhop.com/api/v1/lines \\
  -H "Authorization: Bearer $GETMEME_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "system": "You write one friendly, funny greeting line for a link tracking app.",
    "prompt": "Greet them on a Monday morning. Address them as {name}, exactly once.",
    "maxLength": 80,
    "placeholders": ["name"],
    "forbid": ["acme"]
  }'

{
  "text": "Happy Monday, {name}. The coffee already forgave you.",
  "model": "qwen/qwen3.8-27b:free",
  "reason": null
}

model is the model that actually answered, which is not always the one the service asked for: when a router picks a different model, this is the one it picked. It is null whenever text is.

The same request does not give the same line twice, and there is no idempotency key, so a retry is a second call: a second model request and a second slot off your rate limit.

And when there is no line

{
  "text": null,
  "model": null,
  "reason": "guard:max_length"
}

Still 200. Responses are never cached: everything carries Cache-Control: no-store.

You write the voice, getmeme writes the shape

Whatever you send as system is kept, and the service appends its own rules after it: answer with one JSON object, one line, under the cap, no markdown, no em dash, no links, no stray brackets, and exactly which placeholders are allowed.

Those appended rules are the same ones the guards enforce, so the model is told the contract it is being held to instead of being failed for a rule it never saw. Use system for voice. The formatting is handled.

Send tokens, not people

placeholders exists so that personal data never reaches a model provider. Ask for {name}, get a line with {name} in it, and substitute on your side. A token you did not declare is rejected, so the model cannot invent a hole you have no value for.

What getmeme keeps, and who sees it

Every call is stored for 14 days: your system and prompt as they were sent, each model's raw answer, and the line you got back. It is kept so a call that went wrong can be explained afterwards, it is readable only by getmeme, and a daily job deletes anything older. Your forbid terms are never stored, only how many there were.

Prompts are sent to OpenRouter, which passes them to whichever model answers. When the named model is unavailable the request falls through to OpenRouter's free router, which picks among free models that are up at that moment, so the provider that sees a given prompt is not fixed in advance. getmeme does not train on your prompts and has no say in what a downstream provider does with them.

Words you never want printed

forbid is checked against the answer and is never put in a prompt. That is deliberate. These are usually the words you are not ready to publish, an unreleased name or a partner under wraps, and listing them in a prompt would hand every one of them to the model provider in order to avoid printing them.

Matching is case insensitive and runs after Unicode normalisation, so a full-width lookalike does not slip past it.

The eight guards

Every line is checked in this order. The first rejection wins, nothing is repaired, and the guard that stopped it is named in reason. They cannot be turned off.

1. 1normalise Folds Unicode to NFKC, trims, strips wrapping quotes. Empty after that is a rejection.
2. 2single_line Any line break at all.
3. 3no_markdown Backticks, asterisks, tildes, bullets, headings, link syntax.
4. 4max_length Longer than your cap, counted in characters rather than bytes.
5. 5no_em_dash An em dash. House style, and rejected rather than swapped for something narrower.
6. 6placeholders Square or angle brackets, any {token} you did not declare, and other template syntax: ${'$'}{, %s, %d.
7. 7no_urls_or_emails A link, a bare domain on a common suffix, or an @ between two non-spaces. It is a regex, not a validator, so an unusual suffix can pass.
8. 8forbid Any substring from your forbid list.
9. What survives all eight is the line you get.

A rejection ends the request. getmeme does not go and ask another model for another line, so a guard: reason means one model wrote one line and it failed. Call again if you want another, and know that it costs a slot.

When there is no line

The response is 200 with "text": null whenever nothing usable came back. It is never an error status, so the happy path of a page render needs no error handling at all. Keep a static line, show it immediately, and swap in a generated one when it arrives.

A guard: reason is the useful one: it is the only one that points at your own request rather than at the state of a model provider. If you keep seeing guard:max_length, your maxLength is tighter than the line you are asking for. Treat a reason you do not recognise as "no line": the list can grow.

Rate limits

Each key has a per-minute and a per-day limit. A new key starts at 15 requests a minute and 500 a day unless you asked for something else. Ask if you need them raised: a change applies on your next request, with no new key and no redeploy.

Over a limit is 429 rate_limited with Retry-After in seconds. Back off and show your static line in the meantime.

A 401 carries none of these headers, because the limiter runs after your key is accepted. A 400 or 415 carries them and costs you a request: the limiter runs before the body is validated.

Errors

Every error has the same shape, and requestId matches the X-Request-Id response header. Quote it when you report a problem and the call can be looked up exactly.

{
  "error": {
    "code": "invalid_request",
    "message": "maxLength: too small",
    "requestId": "9f1c2e5a-..."
  }
}

Note what is not in this table: a line that no model could write, and a line every model wrote badly. Those are both 200. See when there is no line.

Health and the spec

Two API routes take no key.

Returns { "ok": true, "db": true, "version": "0.1.0" }, or 503 when the database is unreachable.

The machine-readable spec, OpenAPI 3.1, generated by the running service and covering the same routes this page does. Point your client generator at /api/v1/openapi.json rather than at this page: it is the version that cannot drift.

Treat /health as the status page. If it answers and your call does not, the problem is more likely your key or your request than the service.