Moqi dans ton code. Et dans Claude.

Authentification

Crée une clé API depuis ta page API, 5 au plus. Passe-la dans l'en-tête Authorization de chaque requête, ou dans x-api-key. Garde-la secrète : elle dépense tes Moqi.

Authorization: Bearer moqi_live_xxxxxxxxxxxxxxxx

URL de base : https://moqi.fr/api/v1

Sans clé : le flux d'appareil

Si ton outil est utilisé par quelqu'un d'autre, ne lui demande pas de coller une clé : elle finirait dans son historique de terminal. Utilise le flux d'appareil, celui de gh auth login (OAuth 2.0, RFC 8628). Tu affiches un code à huit caractères, la personne l'entre sur moqi.fr, et tu reçois la clé.

# 1. ouvrir la demande (aucune clé nécessaire)
curl -X POST https://moqi.fr/api/v1/appareil \
  -H "Content-Type: application/json" \
  -d '{"nom":"Le nom de ton outil"}'

# renvoie { "user_code": "BDWP-HQND",
#     "verification_uri": "https://moqi.fr/appareil",
#     "device_code": "…", "interval": 5, "expires_in": 600 }

# 2. afficher user_code et verification_uri à la personne,
#    puis sonder toutes les `interval` secondes :
curl -X POST https://moqi.fr/api/v1/appareil/jeton \
  -H "Content-Type: application/json" \
  -d '{"device_code":"…"}'

# renvoie 400 authorization_pending  tant qu'elle n'a pas cliqué
# renvoie 400 slow_down              si tu sondes trop vite
# renvoie 200 { "access_token": "moqi_live_…", "token_type": "Bearer",
#               "expires_in": 7776000 }

La clé n'est rendue qu'une seule fois, elle expire au bout de 90 jours (expires_in, en secondes), et elle se révoque depuis la page API. Elle naît avec un plafond de dépense par jour, que la personne règle sur sa page API. Elle porte le nom que tu as déclaré, ce qui permet de retrouver laquelle couper. Ce nom ne peut pas contenir « Moqi », et la personne tape elle-même le code sur la page d'autorisation : rien ne le pré-remplit.

À afficher avec le code : « n'entre ce code que si tu viens de le voir apparaître toi-même ». Un code obtenu par un tiers et transmis par message est une tentative d'accès au compte de la personne.

MCP : Moqi dans Claude et dans ton agent

Dans Claude : ouvre Personnaliser, puis Connecteurs, choisis « Ajouter un connecteur personnalisé » et colle https://moqi.fr/api/mcp. Claude te propose de te connecter : tu autorises dans une fenêtre Moqi, sans aucune clé à copier. La connexion apparaît sur ta page API, avec son plafond du jour, et se coupe d'un clic.

Moqi expose un serveur MCP. Branché dessus, ton agent voit 51 outils et les appelle lui-même : découper une vidéo, générer une vidéo ou une image, lire l'agenda, y poser une sortie, la décaler, lire les chiffres de tes publications, régler ton style, répondre au support. Tu n'écris aucun code. Un geste qui ne se défait pas revient d'abord avec ce qui serait perdu.

Dans Claude Code, puis /mcp pour te connecter de la même façon :

claude mcp add --transport http moqi https://moqi.fr/api/mcp

Un autre client MCP sans OAuth ? Ajoute l'en-tête Authorization: Bearer moqi_live_… avec une clé de ta page API.

Le serveur demande la connexion dès le premier échange : ton client la détecte tout seul. Une seconde adresse, https://moqi.fr/api/mcp/clips, sert les mêmes outils sans la génération de vidéos et d'images.

Pas développeur ? La marche à suivre pas à pas, et ce que Claude peut faire sur ton compte, est sur Moqi dans Claude.

Les outils portent leur prix et leurs pièges dans leur description, et le serveur envoie ses consignes à l'agent : un découpage de cinq clips est un seul appel, une génération de cinq vidéos en fait cinq. Les refus portent reessayable, pour qu'un agent sache s'il doit recommencer ou prévenir la personne ; les refus historiques du lancement d'un découpage, plus bas, n'en ont pas.

Endpoints

curl -X POST https://moqi.fr/api/v1/decoupages \
  -H "Authorization: Bearer moqi_live_xxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://youtu.be/xxxx",
    "clipCount": 10,
    "clipMax": 60,
    "hook": true
  }'

{
  "id": "3c1d23fa-...",
  "status": "pending",
  "suivre": "/api/v1/decoupages/3c1d23fa-...",
  "langue_sous_titres": "auto"
}

{
  "id": "3c1d23fa-...",
  "etat": "fini",
  "avancement": 100,
  "clips": [
    {
      "position": 1,
      "titre": "...",
      "duree_s": 32.5,
      "description": "Texte de légende optimisé",
      "hashtags": "#nostalgie #annees90 #culturepub",
      "score": 87,
      "raison_du_score": "...",
      "vignette_url": "https://...",
      "fichier_url": "https://..."
    }
  ]
}

Tout le reste se pilote aussi : le prix d'un découpage avant de le lancer, les moments écartés à fabriquer, renommer ou supprimer une vidéo ou un clip, les vidéos et images générées, l'agenda et la publication TikTok, ton style, tes statistiques et le support. Chaque adresse, son corps, son prix et ses erreurs sont dans le catalogue, lisible par une machine : https://moqi.fr/api/v1/catalogue. Restent sur le site : payer, ton abonnement, tes réglages de publication TikTok, tes clés et ton mot de passe.

Pour n8n, Make ou Postman, le même catalogue au format OpenAPI : https://moqi.fr/api/v1/openapi.json. Importe-le, et chaque action de l'API devient un bloc prêt à brancher.

Limites

• Le nombre de clips et la durée sont les mêmes pour tous les comptes : jusqu'à 15 clips par vidéo, ou toute la vidéo dans l'ordre, en parties de 30 s à 2 min au choix (60 au plus, 45 à 2 min), des clips jusqu'à 2 min, une source jusqu'à 4 h.
• Seul ce qui fabrique débite des Moqi : un découpage, une vidéo ou une image générée, un moment à la carte. Lire, programmer, publier et régler ne coûtent rien. Le même solde que le site, au même prix ; les montants que rend l'API, comme solde, credits_par_mois, manque ou reste, sont en Moqi.
• L'API, le serveur MCP et les crochets sont ouverts à tous les comptes. Les gestes gardent les portes du site : programmer, publier et ton style dès Créateur.
• Trois découpages en cours en même temps au plus, le site compris, et un plafond de dépense par jour pour chaque clé, réglable sur ta page API. Une écriture rejouée dans les 24 heures avec la même clé d'idempotence ne s'exécute qu'une fois.

Crochets : Moqi te rappelle

Plutôt que de sonder, donne une adresse : Moqi la rappelle quand un travail se termine. Six évènements : decoupage.fini, decoupage.echoue, creation.prete, creation.echouee, publication.publiee et publication.echouee, quand une vidéo passe en ligne sur un réseau, ou qu'il la refuse. Les deux évènements de publication portent sortie, l'identifiant rendu par POST /v1/publications. Un échec avec certaine: false veut dire que le réseau n'a pas répondu : la vidéo est peut-être en ligne, vérifie avant de la relancer. Une vidéo avec voix off ou sous-titres s'annonce quand ils sont posés, avec habillage : pret, ou echec (la vidéo d'origine, et la part de l'habillage rendue).

L'adresse se règle depuis ta page API, jamais par un appel : une adresse de rappel passée dans une requête serait une porte ouverte sur notre réseau interne. Elle doit être en https, et nous ne suivons aucune redirection.

POST https://ton-serveur.fr/moqi
x-moqi-evenement: decoupage.fini
x-moqi-horodatage: 1790000000
x-moqi-signature: sha256=2f1c…

{"evenement":"decoupage.fini","horodatage":1790000000,
 "donnees":{"decoupage":"…","clips":5}}

Vérifie la signature avant de croire l'appel. C'est un HMAC-SHA256 de <horodatage>.<corps brut> avec le secret donné au réglage. Refuse aussi ce qui est trop vieux : sans ce contrôle, un appel capté peut être rejoué des mois plus tard avec une signature toujours valable.

const attendu = crypto
  .createHmac("sha256", process.env.MOQI_WEBHOOK_SECRET)
  .update(`${entetes["x-moqi-horodatage"]}.${corpsBrut}`)
  .digest("hex");

if (!crypto.timingSafeEqual(Buffer.from(attendu), Buffer.from(recu))) rejeter();

Réponds 2xx : tout le reste compte comme un échec. Au bout de dix échecs de suite, le crochet s'éteint et ta page API dit pourquoi. Réenregistrer l'adresse le rallume, et fabrique un secret neuf.

Sans coder : n8n, Make et Zapier

Deux modèles n8n prêts à importer : dans n8n, ouvre un workflow vide, puis « Import from File ».

Ta clé va dans un identifiant n8n « Header Auth » : Name Authorization, Value Bearer suivi de ta clé. Jamais dans le modèle lui-même.

Make, en quatre étapes

1. 1Webhooks, « Custom webhook » : copie son adresse et colle-la dans « Rappel automatique » sur ta page API. Make apprend la forme de l'appel au premier rappel reçu.
2. 2Un filtre sur evenement égal à decoupage.fini.
3. 3HTTP, « Make a request » : GET https://moqi.fr/api/v1/decoupages/ suivi de donnees.decoupage, un en-tête Authorization à Bearer suivi de ta clé, et « Parse response » activé.
4. 4Flow Control, « Iterator » sur clips : un passage par clip, avec fichier_url. Branche ensuite ton Drive, ton Dropbox ou ton Slack.

Le scénario relit le découpage chez Moqi avec ta clé : il ne croit jamais le contenu de l'appel seul. Pour lancer un découpage depuis Make, un « Make a request » en POST sur https://moqi.fr/api/v1/decoupages avec le corps JSON {"url": "…", "clipCount": 5}.

Zapier : le même montage, avec « Webhooks by Zapier » (Catch Hook) puis une requête GET. Ce module est réservé aux offres payantes de Zapier.

Erreurs

Le lancement d'un découpage (POST /api/v1/decoupages, comme son adresse d'origine /api/v1/clips) répond { "error", "message" } pour ses refus historiques : missing_url, invalid_url, live_url, email_required, rate_limited, quota_exceeded, too_many_active et create_failed. Tout le reste répond { "erreur": { "code", "message", "reessayable" } }, et reessayable dit s'il faut recommencer : jamais, oui ou apres-action.