# Remove a redirect permanently

`DELETE /api/v1/redirects/{redirectId}`

Removes the redirect. IT TAKES NO BODY AT ALL, unlike the other writes on this api: the row is named entirely by the path and nothing is read from the request. NEEDS BOTH GRANTS. The qualified scope named above is refused to a key holding write_redirects alone, and the split is what this family is the plainest case for: a nightly importer that upserts is repaired by the next run, and one that deletes is not. NOTHING FAILS AT THE MOMENT IT HAPPENS, which is the whole hazard. The resource IS the repair for a dead link, so removing it restores the breakage: the old path 404s again, every inbound link and search result pointing at it dies, and the only signal is organic traffic falling off a week later. There is no deleted_at, no tombstone and no restore, and for a migrated store rebuilding means knowing which paths the store used to serve, which is thousands of rows nobody has a second copy of. No money and no stock move, and nothing is emitted. WHY IT EXISTS ANYWAY: from_path is immutable and the PATCH refuses it by name, so this is the only route to a corrected source path. Delete, then create the redirect again with the from_path you meant, which mints a new id. IDEMPOTENCY HERE IS PER KEY, NOT PER RESOURCE. Replaying the same Idempotency-Key returns the stored 204 without touching anything. A FRESH key against a redirect that is already gone is 404, because "your retry already landed" and "there is no such redirect" are different facts, and a 204 for a mistyped id would let a reconciliation record the row as removed while the real redirect kept answering.

## Path parameters

- `redirectId` (string, required)

## Headers

- `Idempotency-Key` (string, required) — A unique key per logical write. Replaying a request with the same key returns the first response byte for byte instead of applying the write twice.

## Responses

- `204` — Success. The response has no body.
- `400` — The request was refused before any state changed. `code` is one of:

`invalid_body`, a write body this route will not take. `reason` partitions it
and `field` names the key when one key is at fault.
`invalid_query`, a query parameter, including limit and after.
`invalid_text`, a NUL byte or bytes that are not valid UTF-8 anywhere in the
path, the query or the body. Strip control characters before sending.
`idempotency_key_required`, a write sent without the Idempotency-Key header.
`invalid_request`, an Idempotency-Key longer than 255 bytes.

Routes add their own codes for rules only they know. Switch with a default arm.
- `401` — No credential, or one this API does not accept. `code` is always
`unauthorized`.

THE BODY IS DELIBERATELY UNINFORMATIVE. An expired key, a revoked key, a
publishable key, a key belonging to another merchant and a key that never
existed are all refused with the same bytes, so this response cannot be used to
probe which keys exist. Check the key's state in the dashboard rather than
inferring it here.

Send the key as `Authorization: Bearer <key>` or as `X-API-Key: <key>`. It is
never accepted in a query string.
- `403` — The key lacks a required scope. `code` is `insufficient_scope`. This route is gated TWICE, on write_redirects and then on write_redirects:delete, and the message names whichever gate refused. A key holding neither is refused naming write_redirects, because that gate runs first: seeing the parent named does NOT mean the qualifier would have been enough. Ask the merchant for both. The qualifier cannot be granted on its own in any case, since it narrows the parent rather than replacing it.
- `404` — The resource this url addresses does not exist, or never did on this store.

`resource` names the kind of thing that was missing and is the half to branch
on: the code is `not_found` on newer routes and a per-entity spelling on
routes that shipped before that rule, and the two mean the same thing.

A 404 is ALWAYS about the url. An id inside the request body that resolves to
nothing is 422 `unprocessable_reference` instead, so the two cases stay
distinguishable. An id that belongs to a different merchant reads exactly like
one that never existed.
- `409` — The request is well formed and the store's current state refuses it.

EVERY WRITE CAN ANSWER TWO OF THESE, whatever it does:
`idempotency_key_reused`, this Idempotency-Key already served a different
method, path or body. The key namespace is per store and not per endpoint, so a
key built from a business id collides across routes; use a fresh key per
logical write.
`idempotency_key_in_progress`, an identical request is still running. Retry
after a short delay; exactly one of the racing calls will have applied.

`not_configured` means the merchant has not set something up yet, with
`resource` naming what. The remaining codes are the per-route state rules named
on the operation.
- `413` — The request body exceeded the cap named in the message. `code` is
`payload_too_large`. Nothing was read and nothing was recorded, so the same
Idempotency-Key may be reused once the body is smaller.
- `415` — The body was not declared as `application/json`. `code` is
`unsupported_media_type`.

This API reads ONE media type. The `+json` structured suffixes are refused
too, because they name semantics (merge-patch in particular) this API does
not implement, and reading such a body as plain JSON would be a silent
misreading. A write that carries NO body needs no Content-Type at all.
- `429` — Too many requests. `code` is `rate_limited`.

Two limits apply independently: one on the credential and the route family,
one on the client address. The headers describe whichever has less left, so
honouring Retry-After always clears the window that bound.
- `default` — Any status this operation does not list, in the same envelope.

A 5xx means the request may or may not have applied. Retry it with the SAME
Idempotency-Key: that is the only way to find out without risking a duplicate,
and it is what the key is for.

A few 4xx conditions arrive here rather than as a listed status because they
depend on the merchant's plan or on a module being wired: 402 when a quota or a
plan limit is reached, and 503 when a capability the route needs is not
configured on this deployment. Both carry a `code` naming which.

## Example

```bash
curl --request DELETE \
  --url 'https://api.mercemur.com/api/v1/redirects/{redirectId}' \
  --header 'Authorization: Bearer <token>'
```