Documentation

export GLIIZ_API_BASE="https://www.gliiz.com/api/public/v1"
export GLIIZ_API_KEY="gliiz_your_secret_key"

curl "$GLIIZ_API_BASE/me" \
  -H "Authorization: Bearer $GLIIZ_API_KEY"

Generate a key from Account Settings → API (Owner or Admin, Starter plan and up — or a free account holding a purchased credit balance). A key is scoped to exactly one project and shown in full only once at creation. Send it as a Bearer token on every request:

curl https://www.gliiz.com/api/public/v1/me \
  -H "Authorization: Bearer gliiz_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

All v1 routes use JSON, and webhooks deliver signed JSON to you. Keep the key server-side only: never expose it in a browser, public mobile app, or embedded script.

const GLIIZ_API_BASE = "https://www.gliiz.com/api/public/v1";

async function gliiz(path: string, init: RequestInit = {}) {
  const res = await fetch(`${GLIIZ_API_BASE}${path}`, {
    ...init,
    headers: {
      "Authorization": `Bearer ${process.env.GLIIZ_API_KEY}`,
      "Content-Type": "application/json",
      ...init.headers,
    },
  });

  const json = await res.json().catch(() => ({}));
  if (!res.ok) throw new Error(json.error ?? `Gliiz API error ${res.status}`);
  return json;
}

The easiest path is deliberately linear: verify the project, generate copy, generate or reuse a visual, then schedule. Webhooks let you receive long-running generations without keeping a connection open.

// 1) Vérifier le projet et les crédits
const me = await gliiz("/me");
console.log(me.project.name, me.credits?.remaining);

// 2) Générer des légendes adaptées à la marque du projet
const copy = await gliiz("/generate/copy", {
  method: "POST",
  body: JSON.stringify({
    prompt: "Annonce le lancement de notre nouvelle offre premium",
    platforms: ["instagram", "linkedin"],
    contentKind: "image"
  }),
});

// 3) Générer un visuel IA. La réponse est souvent async: gardez le jobId.
const flyer = await gliiz("/generate/flyer", {
  method: "POST",
  body: JSON.stringify({
    prompt: "Flyer premium pour le lancement d'une offre marketing IA",
    format: "portrait",
    outputQuality: "2k",
    modelTier: "standard",
    variantCount: 1
  }),
});

// 4) Si besoin, connecter un compte réseau social (générer l'URL OAuth sécurisée)
const connection = await gliiz("/social/connect", {
  method: "POST",
  body: JSON.stringify({ platform: "linkedin" }),
});
console.log("Connect URL:", connection.connect_url);

// 5) Quand l'asset est disponible (via webhook ou /assets), planifier le post
await gliiz("/posts", {
  method: "POST",
  body: JSON.stringify({
    content_item_id: "content-item-uuid",
    caption: copy.copy.linkedin.caption,
    platforms: ["linkedin"],
    scheduled_at: "2026-09-01T09:00:00.000Z"
  }),
});

{
  "project": { "id": "uuid", "name": "Acme", "created_at": "2026-08-12T10:00:00Z" },
  "credits": { "monthly_limit": 200, "used": 42, "purchased_balance": 25, "remaining": 183 },
  "connected_accounts": [
    { "platform": "instagram", "account_name": "acme", "account_type": "business", "active": true }
  ]
}

curl "$GLIIZ_API_BASE/assets?limit=10" \
  -H "Authorization: Bearer $GLIIZ_API_KEY"

{
  "prompt": "Présente notre nouvelle offre premium pour PME",
  "platforms": ["instagram", "linkedin"],
  "contentKind": "image"
}

{
  "prompt": "Flyer premium pour annoncer une offre marketing IA pour restaurants",
  "format": "portrait",
  "outputQuality": "2k",
  "modelTier": "standard",
  "visualType": "hybrid",
  "variantCount": 1,
  "generationRequestId": "launch-offer-2026-09-01"
}

# 1. Générer l'URL d'autorisation OAuth pour LinkedIn
curl -X POST https://www.gliiz.com/api/public/v1/social/connect \
  -H "Authorization: Bearer gliiz_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"platform": "linkedin"}'

# 2. Ou lister les plateformes connectables et comptes actifs
curl https://www.gliiz.com/api/public/v1/social/connect \
  -H "Authorization: Bearer gliiz_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

// Réponse / Response POST (200 OK):
{
  "platform": "linkedin",
  "name": "LinkedIn Personnel",
  "status": "ready",
  "connect_url": "https://www.gliiz.com/api/auth/linkedin?projectId=prj_123456789",
  "instructions": "Ouvrez cette URL dans votre navigateur pour autoriser Gliiz. Une fois le flux OAuth terminé, votre compte sera lié automatiquement à ce projet.",
  "connected_accounts_count": 0
}

{
  "content_item_id": "2f67a5b0-6b0b-47fb-84f0-a077e0d2dd9e",
  "caption": "Votre légende prête à publier...",
  "platforms": ["instagram", "facebook"],
  "scheduled_at": "2026-09-01T09:00:00.000Z",
  "account_by_platform": {
    "instagram": "social-account-uuid"
  }
}

When you create a webhook, Gliiz returns a whsec_… secret shown once. Every POST delivery includes X-Gliiz-Timestamp and X-Gliiz-Signature. Verify the HMAC-SHA256 signature over `${timestamp}.${body}` before processing the event.

curl "$GLIIZ_API_BASE/webhooks" \
  -X POST \
  -H "Authorization: Bearer $GLIIZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production backend",
    "url": "https://example.com/webhooks/gliiz",
    "events": ["generation.completed", "generation.failed", "post.scheduled"]
  }'

{
  "webhook": {
    "id": "webhook-subscription-uuid",
    "name": "Production backend",
    "url": "https://example.com/webhooks/gliiz",
    "events": ["generation.completed", "generation.failed", "post.scheduled"],
    "created_at": "2026-08-12T10:00:00.000Z",
    "secret": "whsec_copy_this_once"
  }
}

import crypto from "crypto";

const timestamp = request.headers["x-gliiz-timestamp"];
const signature = request.headers["x-gliiz-signature"];
const expected = "sha256=" + crypto
  .createHmac("sha256", process.env.GLIIZ_WEBHOOK_SECRET!)
  .update(`${timestamp}.${rawBody}`)
  .digest("hex");

if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
  throw new Error("Invalid Gliiz webhook signature");
}

{
  "id": "evt_01J...",
  "event": "generation.completed",
  "created_at": "2026-08-12T10:02:14.000Z",
  "project_id": "project-uuid",
  "data": {
    "api_key_id": "api-key-uuid",
    "job_id": "generation-job-uuid",
    "workflow": "flyer.v1",
    "status": "completed",
    "result": {
      "contentItemId": "content-item-uuid",
      "imageUrl": "https://..."
    }
  }
}

Available events: generation.copy.completed, generation.flyer.queued, generation.completed, generation.failed, post.scheduled, post.rescheduled, post.published, post.failed, post.canceled, webhook.test.

A failed delivery is REPLAYED: six attempts in all, at 1 min, 5 min, 30 min, 2 h then 6 h. A restart on your side, a deploy, a latency spike — the event still reaches you. The replay sends exactly the same payload, so the same event id: deduplicate on it and a replay is recognised instead of counted twice. Only the signature is recomputed, with a fresh timestamp.

API errors are deliberately simple: an HTTP status, a readable error field, and sometimes details/code for validation. Handle at least the statuses below.

{
  "error": "Invalid post payload",
  "code": "invalid_request",
  "request_id": "6f1c2b7e-9a4d-4d2f-8f0a-1b7c3e5d9a02",
  "details": {
    "fieldErrors": {
      "platforms": ["Array must contain at least 1 element(s)"]
    }
  }
}

Branch your code on code, never on error. The code field is present on EVERY public API error and its value is stable; error is a human-readable message that may be reworded, and is not guaranteed to be in any given language. request_id identifies the response in our logs: quote it to support rather than describing the error.

Some routes are more specific: already_published and too_late on DELETE /posts/:id, invalid_idempotency_key on POST /posts. A few legacy codes are uppercase (PROJECT_REQUIRED, DUPLICATE_REQUEST): they are kept verbatim, precisely so integrations already reading them keep working.

Your quotas travel on EVERY response, not just on the 429 that refuses — so you never have to hit the wall to find out where it is. Two limits stack, per key: a per-minute rate, and a daily volume resetting at midnight UTC.

Capabilities above depend on the permissions each platform grants Gliiz at connection time and can change if a platform updates its policies. If a feature you expect is missing on a connected account, try reconnecting it from Settings → Accounts.

Limits by plan, Free included. Beyond these, every call (Claude, ChatGPT or Gemini) gets a 429 until the window resets — remaining counters travel on every response, see the X-RateLimit-* headers above:

The two columns don't measure the same thing: the per-minute limit caps a burst, the per-day limit caps sustained volume across the whole day. A Starter account sustaining 20/min without a break would exhaust its 300 requests in 15 minutes, then wait until the next day. They are not two ways of saying the same limit.

Shared by Claude and ChatGPT, you only create it once. Account Settings → API → Create a key. The full key (prefix gliiz_…) is shown only at that exact moment. Copy it right away: it will never be shown in full again (only an 8-character prefix stays visible, to recognize it in the list). If you lose it, revoke it and create a new one: revoking one key doesn't affect the others.

From Claude Desktop or claude.ai, the URL to paste into "Add custom connector":

https://www.gliiz.com/api/mcp/claude

Claude then opens a Gliiz page: sign in, pick the project to authorize, and you are done. No API key is involved in this path.

In a terminal, from any folder:

claude mcp add --transport http gliiz https://www.gliiz.com/api/mcp/claude \
  --header "Authorization: Bearer gliiz_YOUR_API_KEY" \
  --scope user

--scope usermakes the connector available from any folder, not just the one you added it from, recommended for everyday use. Don't have Claude Code installed? The official command (macOS/Linux):

curl -fsSL https://claude.ai/install.sh | bash

Once registered, day-to-day use is no longer a sequence of commands: just type claude in a terminal, which opens a real conversation, and describe what you want in plain language (see step 3 below). No extra install, no restart needed beyond the command itself.

Five screens, in this exact order:

Server URL (the "URL" field, screen 3), copy-paste directly:

https://www.gliiz.com/api/mcp/chatgpt

Authentication (screen 4): pick "API key", then paste your key from step 1 into the field, no Bearer prefix, no space before or after:

gliiz_YOUR_API_KEY

Inside a conversation, open the tools picker (+ icon) and check "Gliiz". Activation is per conversation: a conversation already open before you added the connector won't see it retroactively, you need to open a new one or enable it manually in that same one.

Gemini has its own MCP surface, separate from Claude's and ChatGPT's. It serves the same tool set as ChatGPT — since Gemini generates images natively, gliiz_generate_flyer is not exposed to it: it imports what it created through gliiz_import_asset.

The MCP server URL to declare in Gemini:

https://www.gliiz.com/api/mcp/gemini

In a Gemini client that reads an MCP configuration file, declare the server like this. The key comes from step 1 above:

{
  "mcpServers": {
    "gliiz": {
      "url": "https://www.gliiz.com/api/mcp/gemini",
      "headers": {
        "Authorization": "Bearer gliiz_VOTRE_CLE_API"
      }
    }
  }
}

To check that the key and URL answer, before even configuring the client:

curl -X POST https://www.gliiz.com/api/mcp/gemini \
  -H "Authorization: Bearer gliiz_VOTRE_CLE_API" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

No special command to learn. Once the connector is enabled, you describe what you want in plain language, and the assistant decides ON ITS OWN whether to call a Gliiz tool, exactly as it would decide to use a web search if it needed one. You never need to write "use the Gliiz MCP" or name a tool:

For best results: give useful context in your sentence (target platform, desired tone, which project if you have several) rather than letting the assistant guess. If it's unsure between several tools or projects, it will ask before acting, it never silently improvises a publication or a credit spend.

Ask a question that forces the assistant to call a read-only tool, valid for both Claude and ChatGPT. No credits spent, no risk:

What's the AI credit balance on my Gliiz account, and which social accounts are connected?

Expected behavior: the assistant announces it's calling a tool ("Gliiz", gliiz_get_account), then answers with your real balance and real accounts, the same numbers as Account Settings → API in the app. If it answers without ever mentioning a tool, or with an authentication error, redo step 1 (key mispasted, stray space, or a revoked key) then step 2/2-alt (restart missed on Claude, connector not checked in THIS conversation on ChatGPT, or plan still Free/Starter).

Claude gets the full creative studio (it has no native image or video generation). ChatGPT already generates images: it gets gliiz_import_asset instead, to bring what it just produced into your Gliiz library.

Real example, with gliiz_publish_post (the only tool marked destructiveHint): you write

Post to Instagram and LinkedIn: "We're hiring! Designer role open, link in bio."

The assistant never publishes right away. It replies by proposing a scheduling time (at least 1 minute out, often picking a sensible slot itself, or asking you), waits for your confirmation in the conversation, and only then calls the tool. What you'll actually see: the post sits as pending_review in your Gliiz library until the scheduled time, visible from the app if you want to cancel it before it goes out, exactly like a post scheduled from the interface itself. For a generation (visual or video), expect a two-step reply: the assistant announces the start and, for video, must call gliiz_check_generation_status back itself a moment later, it never sits silently blocked waiting for the result.