API reference

curl https://mogger.dev/api/v1/mog \
  -H "Authorization: Bearer $MOGGER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "formula": "bio-mog",
    "text": "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined."
  }'

const res = await fetch("https://mogger.dev/api/v1/mog", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    formula: "bio-mog",
    text: "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.",
  }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

const { mogs, noul } = data.results["bio-mog"];
console.log(mogs, noul);

import os

import requests

res = requests.post(
    "https://mogger.dev/api/v1/mog",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    json={
        "formula": "bio-mog",
        "text": "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.",
    },
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

result = data["results"]["bio-mog"]
print(result["mogs"], result["noul"])

# With the mogger skill installed, ask in plain words, for example:
#   Score this with mogger (bio-mog): I restore 1970s synthesizers for a living. 312 repaired,...
# The skill sources its helpers and runs:
score_text bio-mog 'I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.' | jq '.results'

{
  "results": {
    "bio-mog": {
      "mogs": true,
      "noul": 0.94,
      "version": 1
    }
  },
  "cost": 1,
  "quota": {
    "remaining": 999,
    "budget": 1000
  },
  "request_id": "req_0MHmB7xKQ2c9tVwLp4ZsYd3R"
}

type MogResponse = {
  /** One entry per formula, keyed by the slug or id you sent. */
  results: Record<string, MogResult>;
  /** Units charged: 1 for text, 10 with an image. */
  cost: number;
  quota: { remaining: number; budget: number };
  request_id: string;
};

type MogResult = {
  /** The verdict. */
  mogs: boolean;
  /** Calibrated probability that the answer is yes, 0 to 1. */
  noul: number;
  /** Formula revision. Scores from different versions are not comparable. */
  version: number;
};

# Build the body in a file: a base64 image is too long for a shell argument.
# For a PNG or WebP file, change image/jpeg to image/png or image/webp.
{
  printf '{"formulas":["jawline","canthal-tilt"],"image":"data:image/jpeg;base64,'
  base64 < photo.jpg | tr -d '\n'
  printf '"}'
} > body.json

curl https://mogger.dev/api/v1/mog \
  -H "Authorization: Bearer $MOGGER_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @body.json

// Node 18 or later, as an ES module (mog.mjs). Use image/png or image/webp for other file types.
import { readFile } from "node:fs/promises";

const image = "data:image/jpeg;base64," + (await readFile("photo.jpg")).toString("base64");

const res = await fetch("https://mogger.dev/api/v1/mog", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ formulas: ["jawline", "canthal-tilt"], image }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

for (const [slug, r] of Object.entries(data.results)) {
  console.log(slug, r.mogs, r.noul);
}

import base64
import os

import requests

with open("photo.jpg", "rb") as f:
    image = "data:image/jpeg;base64," + base64.b64encode(f.read()).decode("ascii")

res = requests.post(
    "https://mogger.dev/api/v1/mog",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    json={"formulas": ["jawline", "canthal-tilt"], "image": image},
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

for slug, r in data["results"].items():
    print(slug, r["mogs"], r["noul"])

# With the mogger skill installed, ask in plain words, for example:
#   Does ./photo.jpg mog on jawline and canthal-tilt?
# The skill base64-encodes the file in the shell, so the image
# never enters the model context, and runs:
score_image ./photo.jpg jawline,canthal-tilt | jq '.results'

curl https://mogger.dev/api/v1/mog/f_7Kq2xW9pLm \
  -H "Authorization: Bearer $MOGGER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined."
  }'

const res = await fetch("https://mogger.dev/api/v1/mog/f_7Kq2xW9pLm", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    text: "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.",
  }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.results["f_7Kq2xW9pLm"]);

import os

import requests

res = requests.post(
    "https://mogger.dev/api/v1/mog/f_7Kq2xW9pLm",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    json={
        "text": "I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.",
    },
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["results"]["f_7Kq2xW9pLm"])

# With the mogger skill installed, a custom id works anywhere a slug does:
score_text f_7Kq2xW9pLm 'I restore 1970s synthesizers for a living. 312 repaired, 4 ruined.' | jq '.results'

curl https://mogger.dev/api/v1/formulas \
  | jq -r '.formulas[] | [.slug, .input, .name] | @tsv'

const res = await fetch("https://mogger.dev/api/v1/formulas");
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

for (const f of data.formulas) console.log(f.slug, f.input, f.name);

import requests

res = requests.get(
    "https://mogger.dev/api/v1/formulas",
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

for f in data["formulas"]:
    print(f["slug"], f["input"], f["name"])

{
  "formulas": [
    {
      "id": "jawline",
      "kind": "builtin",
      "slug": "jawline",
      "name": "Jawline",
      "tagline": "Does the jaw draw one clean, defined line from ear to chin?",
      "description": "Scores the lower third of a face: how sharply the jaw is defined, how cleanly it separates from the neck, and how well the chin projects. A beard or camera angle counts only for what it lets the model see.",
      "category": "Face",
      "input": "image",
      "lookFor": [
        "A visible jaw edge running from ear to chin",
        "A defined angle at the back of the jaw",
        "Forward chin projection that balances the face",
        "A clean break between the jaw and the neck"
      ],
      "version": 1,
      "examples": [
        {
          "kind": "image",
          "id": "david",
          "label": "Michelangelo's David, plaster cast",
          "src": "/examples/david-head-cast.jpg",
          "alt": "Plaster cast of the head of Michelangelo's David, three-quarter view facing right, on a black background",
          "credit": "Michelangelo (sculptor). Plaster cast, Statens Museum for Kunst",
          "license": "Public domain",
          "sourceUrl": "https://commons.wikimedia.org/wiki/File:Michelangelo_Buonarroti,_Hoved_fra_statuen_af_David,_,_KAS2232,_Statens_Museum_for_Kunst.jpg",
          "baked": {
            "noul": 0.8927,
            "mogs": true
          }
        }
      ]
    }
  ]
}

type ListFormulasResponse = { formulas: Formula[] };

type Formula = {
  /** Same as slug for built-in formulas. */
  id: string;
  kind: "builtin";
  slug: string;
  name: string;
  tagline: string;
  description: string;
  category: "Face" | "Physique" | "Style" | "Text";
  input: "image" | "text";
  lookFor: string[];
  version: number;
  examples: Example[];
};

type Example =
  | { kind: "text"; id: string; label: string; text: string; baked: Baked }
  | {
      kind: "image";
      id: string;
      label: string;
      /** Path on the site, such as "/examples/david-head-cast.jpg". */
      src: string;
      alt: string;
      credit: string;
      license: string;
      sourceUrl: string;
      baked: Baked;
    };

/** A score computed ahead of time, or null when not scored yet. */
type Baked = { noul: number; mogs: boolean } | null;

curl https://mogger.dev/api/v1/formulas/jawline

const res = await fetch("https://mogger.dev/api/v1/formulas/jawline");
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.formula.input, data.formula.lookFor);

import requests

res = requests.get(
    "https://mogger.dev/api/v1/formulas/jawline",
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["formula"]["input"], data["formula"]["lookFor"])

{
  "id": "f_7Kq2xW9pLm",
  "object": "formula",
  "kind": "custom",
  "title": "Clean product photo",
  "input": "image",
  "prompt": "Is this a clean product photo: one product, centered, evenly lit, on a plain background, with nothing distracting in frame?",
  "criteria": {
    "true": "One product on a plain background, sharp and evenly lit.",
    "false": "Cluttered, dim, off-center, or more than one subject."
  },
  "locked": false,
  "locked_at": null,
  "version": 1,
  "url": "https://mogger.dev/api/v1/mog/f_7Kq2xW9pLm",
  "created_at": "2026-11-07T18:20:00.000Z",
  "updated_at": "2026-11-07T18:20:00.000Z"
}

type CustomFormula = {
  /** "f_" plus 10 letters and digits. */
  id: string;
  object: "formula";
  kind: "custom";
  /** Display only. Never sent to the model. */
  title: string;
  input: "image" | "text";
  /** Creator only, and absent for every key once locked. */
  prompt?: string;
  /** Creator only, and absent for every key once locked. */
  criteria?: { true: string; false: string } | null;
  /** True once the creator locks it. Locking is one way. */
  locked: boolean;
  /** When it was locked, or null. */
  locked_at: string | null;
  version: number;
  /** POST { text } or { image } here to score. */
  url: string;
  created_at: string;
  updated_at: string;
};

curl https://mogger.dev/api/v1/formulas \
  -H "Authorization: Bearer $MOGGER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Clean product photo",
    "prompt": "Is this a clean product photo: one product, centered, evenly lit, on a plain background, with nothing distracting in frame?",
    "input": "image",
    "criteria": {
      "true": "One product on a plain background, sharp and evenly lit.",
      "false": "Cluttered, dim, off-center, or more than one subject."
    }
  }'

const res = await fetch("https://mogger.dev/api/v1/formulas", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    title: "Clean product photo",
    prompt: "Is this a clean product photo: one product, centered, evenly lit, on a plain background, with nothing distracting in frame?",
    input: "image",
    criteria: {
      true: "One product on a plain background, sharp and evenly lit.",
      false: "Cluttered, dim, off-center, or more than one subject.",
    },
  }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.id, data.url);

import os

import requests

res = requests.post(
    "https://mogger.dev/api/v1/formulas",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    json={
        "title": "Clean product photo",
        "prompt": "Is this a clean product photo: one product, centered, evenly lit, on a plain background, with nothing distracting in frame?",
        "input": "image",
        "criteria": {
            "true": "One product on a plain background, sharp and evenly lit.",
            "false": "Cluttered, dim, off-center, or more than one subject.",
        },
    },
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["id"], data["url"])

curl https://mogger.dev/api/v1/formulas/mine \
  -H "Authorization: Bearer $MOGGER_API_KEY"

const res = await fetch("https://mogger.dev/api/v1/formulas/mine", {
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
  },
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

for (const f of data.formulas) console.log(f.id, f.input, f.title);

import os

import requests

res = requests.get(
    "https://mogger.dev/api/v1/formulas/mine",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

for f in data["formulas"]:
    print(f["id"], f["input"], f["title"])

curl -X PATCH https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm \
  -H "Authorization: Bearer $MOGGER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Is this a clean product photo with exactly one product, centered, on a plain background?"
  }'

const res = await fetch("https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm", {
  method: "PATCH",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    prompt: "Is this a clean product photo with exactly one product, centered, on a plain background?",
  }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.version);

import os

import requests

res = requests.patch(
    "https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    json={
        "prompt": "Is this a clean product photo with exactly one product, centered, on a plain background?",
    },
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["version"])

curl -X POST https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm/lock \
  -H "Authorization: Bearer $MOGGER_API_KEY"

const res = await fetch("https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm/lock", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
  },
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.locked, data.locked_at);

import os

import requests

res = requests.post(
    "https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm/lock",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["locked"], data["locked_at"])

curl -X DELETE https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm \
  -H "Authorization: Bearer $MOGGER_API_KEY"

const res = await fetch("https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
  },
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(data.deleted);

import os

import requests

res = requests.delete(
    "https://mogger.dev/api/v1/formulas/f_7Kq2xW9pLm",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(data["deleted"])

curl https://mogger.dev/api/v1/me \
  -H "Authorization: Bearer $MOGGER_API_KEY"

const res = await fetch("https://mogger.dev/api/v1/me", {
  headers: {
    Authorization: `Bearer ${process.env.MOGGER_API_KEY}`,
  },
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`);

console.log(`${data.remaining} of ${data.budget} units left`);

import os

import requests

res = requests.get(
    "https://mogger.dev/api/v1/me",
    headers={"Authorization": f"Bearer {os.environ['MOGGER_API_KEY']}"},
    timeout=60,
)
data = res.json()
if not res.ok:
    raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")

print(f"{data['remaining']} of {data['budget']} units left")

# The mogger skill checks the key and quota with:
api GET /api/v1/me | jq '{label, budget, used, remaining, revoked}'

{
  "label": "build-bot",
  "prefix": "mog_a1B2",
  "budget": 1000,
  "used": 37,
  "remaining": 963,
  "revoked": false,
  "created_at": "2026-11-07T18:20:00.000Z",
  "last_used_at": "2026-11-07T19:02:11.000Z"
}

type KeyStatus = {
  label: string;
  /** First 8 characters of the key, such as "mog_a1B2". */
  prefix: string;
  budget: number;
  used: number;
  remaining: number;
  revoked: boolean;
  /** ISO 8601. */
  created_at: string;
  /** null until the first successful call. */
  last_used_at: string | null;
};

{
  "quota": {
    "remaining": 4,
    "budget": 1000
  },
  "error": {
    "code": "quota_exhausted",
    "message": "This key has 4 of 1000 units left and this request costs 10. Ask for a rotated key"
  },
  "request_id": "req_0MHmB7xKQ2c9tVwLp4ZsYd3R"
}

type MoggerError = {
  error: { code: ErrorCode; message: string };
  request_id: string;
  /** Present on 402 quota_exhausted. */
  quota?: { remaining: number; budget: number };
};

type ErrorCode =
  | "invalid_request"
  | "input_mismatch"
  | "unknown_formula"
  | "unauthorized"
  | "key_revoked"
  | "quota_exhausted"
  | "forbidden"
  | "not_found"
  | "formula_limit_reached"
  | "payload_too_large"
  | "internal_error"
  | "upstream_error";

curl -fsSL https://mogger.dev/install.sh | sh

# Claude Code
mkdir -p ~/.claude/skills/mogger
curl -fsSL https://mogger.dev/skills/mogger/SKILL.md -o ~/.claude/skills/mogger/SKILL.md

# Codex
mkdir -p ~/.codex/skills/mogger
curl -fsSL https://mogger.dev/skills/mogger/SKILL.md -o ~/.codex/skills/mogger/SKILL.md

# The key: an environment variable, or the file the installer writes
export MOGGER_API_KEY=mog_...