NouveauGPT Image 2.6, Kling V4 et Kimi K3.1 Pro sont désormais disponibles.

Tchavi
ModèlesTarifsDocumentationBlog
Tchavi
  • Pourquoi Tchavi
  • Modèles
  • Tarifs

Tchavi est une API d'IA compatible OpenAI : 130+ modèles, du texte à la vidéo, à recharger par mobile money en FCFA ou dans votre monnaie locale, sans carte bancaire.

  • support@tchavi.com
  • Support

Modèles populaires

  • API GPT-6 Sol
  • API Claude Sonnet 5.5
  • API Claude Opus 5.5
  • API Gemini 4 Argon
  • API DeepSeek V4.1 Flash
  • Nano Banana 2.1 (images)
  • GPT Image 2 (images)
  • Wan 3.0 (vidéo)
  • Les 130+ modèles

Développeurs

  • Démarrage rapide
  • Référence API
  • Claude Code
  • Cursor
  • SDK

Ressources

  • Documentation
  • Blog
  • Modèles d'image
  • Modèles vidéo
  • Modèles musique
  • Modèles audio
  • Paiement mobile money
  • Payer les API IA sans carte Visa
  • Prix des API IA en FCFA
  • Claude Code en mobile money

Légal

  • Confidentialité
  • Conditions d'utilisation

API par créateur

  • API OpenAI
  • API Gemini
  • API Claude
  • API Qwen
  • API DeepSeek
  • API Seedance
  • API MiniMax
  • API Mistral

Paiement mobile money · Disponible dans 12 pays : Bénin, Cameroun, Congo, Côte d'Ivoire, Gabon, Kenya, Ouganda, RD Congo, Rwanda, Sénégal, Sierra Leone et Zambie. Opérateurs : Moov Money, MTN MoMo, Airtel Money, Orange Money, M-Pesa, Free Money et Zamtel Kwacha.

© 2026 Tchavi. Tous droits réservés.

Nous utilisons des cookies pour améliorer votre expérience, personnaliser le contenu et analyser notre trafic ; consultez notre Politique cookies.

Retour aux modèles

GPT-6 Luna

openai/gpt-6-luna

L'efficacité GPT-6 pour les tâches ciblées à gros volume

GPT-6 Luna est le palier le plus efficace de la famille GPT-6, sorti chez OpenAI le 22 septembre 2026 avec Sol. OpenAI le destine aux tâches ciblées à haut volume.

Modalités
Entrée / Sortie
0,22 / 1,1cr / 1K
Fenêtre de contexte
1,1 M
Sortie
22 sept. 2026
Capacités
  • Outils
  • Mode JSON
  • Vision
  • PDF
  • Streaming
  • Cache de prompt· lecture 0,022 cr / 1K

Classer des tickets, étiqueter des avis, extraire des champs d'un contrat, trier des e-mails : Luna garde un effort de réflexion réglable (de none à max), la lecture d'images et de documents, les outils et le JSON, avec jusqu'à 128K en sortie.

Sur Tchavi, payez en mobile money sans carte ni KYC, avec des crédits qui n'expirent jamais. Un seul compte et une seule clé API pour 100+ modèles : confiez le gros du flux à Luna, montez vers Sol seulement quand il le faut.

Ce que ce modèle fait bien

  • 📦

    Pensé pour le volume

    Décrit par OpenAI comme son modèle le plus efficace pour le haut débit ciblé

  • 🧠

    Réflexion réglable

    De none à max : aucune pour trier, davantage pour raisonner

  • 👁️

    Images et documents

    Lit captures, scans et fichiers joints en plus du texte

  • 🛠️

    Outils + JSON

    Appel de fonctions et sortie structurée en JSON

  • ✍️

    Sortie jusqu'à 128K tokens

    Assez de place pour de longs résumés ou des lots entiers

  • ⚡

    Streaming

    Affichez la réponse au fil de l'eau

Exemples de prompts

  • Voici 200 avis produit. Étiquette chacun avec un sentiment (positif, neutre, négatif) et la fonctionnalité dont il parle le plus. Réponds en JSON, un objet par avis.

  • Extrais de ce contrat chaque date, montant et contrepartie, avec la phrase source. Renvoie du JSON et signale toute valeur ambiguë plutôt que de deviner.

  • Pour chacun de ces e-mails, décide : réponse humaine nécessaire ou accusé de réception automatique ? Donne une raison en une phrase.

Bon à savoir

  • Réglé pour le débit plutôt que la profondeur. Sur du raisonnement multi-étapes, du code difficile ou des specs ambiguës, il restera derrière GPT-6 Sol et Astra.
  • Les paramètres d'échantillonnage sont ignorés. Ce modèle rejette temperature et top_p : Tchavi les enlève plutôt que de laisser la requête échouer.
  • Les outils de fonction s'exécutent sans raisonnement. Sur /v1/chat/completions, OpenAI n'accepte les outils pour Luna qu'avec `reasoning_effort: 'none'` : Tchavi le fixe quand vous envoyez des outils sans choisir d'effort. Si vous fixez un autre effort, OpenAI rejette la requête.

Spécifications techniques

Fournisseur
openai
Identifiant API
gpt-6-luna
Catégorie
Chat & Texte
Fenêtre de contexte
1 050 000 tokens
Sortie max
128 000 tokens
Rate limit
600 RPM
Unité de facturation
token
Streaming
Oui

Idéal pour

  • Classer images et documents
  • Résumé en masse
  • Routage et étiquetage
  • Lecture de paperasse scannée
  • Pipelines d'enrichissement

Prêt à l'essayer ?

Testez ce modèle dans le playground, sans configuration.

Questions fréquentes

GPT-6 Luna ou GPT-6 Sol, lequel choisir ?

Luna pour les tâches ciblées à gros volume : classer, étiqueter, extraire, trier. Sol dès que la tâche demande du raisonnement en plusieurs étapes, du code ou des documents complexes.

GPT-6 Luna ou GPT-4o mini ?

Luna est de la génération GPT-6, avec un effort de réflexion réglable et la lecture d'images et de documents. GPT-4o mini reste une option si votre pipeline texte tourne déjà dessus.

Lit-il les images et les PDF ?

Oui : images et documents en entrée, texte en sortie, jusqu'à 128K de tokens en sortie. Idéal pour trier des scans ou des captures en lot.

Peut-on couper la réflexion pour aller plus vite ?

Oui : OpenAI propose l'effort none sur Luna, ainsi que low, medium (par défaut), high, xhigh et max. Réglez-le selon la difficulté de chaque tâche.

Puis-je régler temperature et top_p ?

Non : ce modèle les rejette, donc Tchavi les retire de la requête. Fixez le format par vos consignes et le mode JSON.

Comment appeler GPT-6 Luna avec mon SDK OpenAI ?

Remplacez l'URL de base par celle de Tchavi, utilisez votre clé API Tchavi et mettez model: "gpt-6-luna".

Puis-je payer en mobile money, sans carte bancaire ?

Oui. Rechargez votre compte Tchavi avec Orange Money, MTN MoMo, M-Pesa ou un autre opérateur mobile money : aucune carte bancaire n'est nécessaire. Les crédits arrivent dès que le paiement est confirmé et sont débités à l'usage.

L'API est-elle compatible avec celle d'OpenAI ?

Oui. Gardez votre SDK OpenAI actuel, remplacez simplement l'URL de base par celle de Tchavi (visible dans l'onglet API) et utilisez votre clé Tchavi. Le reste de votre code ne change pas.

API

import Tchavi from '@tchavi/sdk';

const client = new Tchavi({ apiKey: 'API_KEY' });

const response = await client.chat.completions.create({
  model: 'gpt-6-luna',
  messages: [
  {
    "role": "user",
    "content": "Hello!"
  }
],
});

console.log(response.choices[0].message.content);
console.log('Credits used:', response.tchavi.credits_used);

Paramètres de l'API

Tous les paramètres acceptés par ce modèle. Consultez le SDK pour les types complets.

modelRequis
string

Identifiant du modèle de chat (ex. `gpt-6-luna`).

messagesRequis
Array<{ role, content }>

Messages de la conversation. Chaque élément a un `role` (system/user/assistant) et un `content` qui peut être soit une chaîne simple, soit un tableau de blocs de contenu (`text`, `image_url`, `document_url`).

temperature
number
Défaut: 1

Température d'échantillonnage entre 0 et 2. Plus haut = plus aléatoire.

max_tokens
integer

Nombre maximum de tokens à générer dans la réponse.

max_completion_tokens
integer

Alias OpenAI pour `max_tokens`. Les deux fonctionnent ; si les deux sont fournis, `max_completion_tokens` prime.

stream
boolean
Défaut: false

Si vrai, les deltas de message partiels sont streamés en Server-Sent Events.

tools
Array<{ type, function }>

Outils pour le function-calling. Passe un tableau de `{ type: "function", function: { name, description, parameters } }`. Les appels d'outils renvoyés sont dans `choices[].message.tool_calls`. Réservé aux modèles avec `supportsTools: true`.

tool_choice
"auto" | "none" | { type, function }

Comment le modèle choisit parmi les outils : `"auto"` (par défaut), `"none"` pour forcer une réponse texte, ou `{ type: "function", function: { name } }` pour forcer un outil précis. Uniquement avec `supportsTools: true`.

response_format
{ type: "json_object" | "text" }

Contraint la sortie. Passe `{ type: "json_object" }` pour forcer un JSON valide (le modèle a quand même besoin d'une instruction JSON dans le prompt). Uniquement avec `supportsJsonMode: true`.

reasoning_effort
"low" | "medium" | "high"

Profondeur de raisonnement sur les modèles OpenAI o-series / GPT-5. Valeurs `"low"`, `"medium"`, `"high"`. Ignoré silencieusement par les autres modèles OpenAI.

Voir tous les paramètres (22)
top_p
number
Défaut: 1

Échantillonnage nucleus : seuls les tokens dans la masse de probabilité `top_p` sont considérés.

seed
integer

Graine entière pour une sortie déterministe. Même seed + même requête = même complétion, quand le fournisseur le supporte. OpenAI l'honore ; Anthropic l'ignore.

n
integer
Défaut: 1

Nombre de complétions à générer en un appel. Défaut 1 ; chaque complétion supplémentaire est facturée.

stream_options
{ include_usage?: boolean }

Options de streaming, ex. `{ "include_usage": true }` pour recevoir un dernier chunk SSE avec les compteurs d'usage. Effectif uniquement quand `stream: true`.

stop
string | string[]

Jusqu'à 4 séquences après lesquelles l'API cesse de générer.

frequency_penalty
number
Défaut: 0

Entre -2.0 et 2.0. Les valeurs positives pénalisent les tokens fréquents.

presence_penalty
number
Défaut: 0

Entre -2.0 et 2.0. Les valeurs positives encouragent à parler de nouveaux sujets.

user
string

Identifiant utilisateur final transmis au fournisseur pour le suivi modération / abus. Doit rester stable par utilisateur.

logit_bias
Record<string, number>

Biais logit par token `{ "<tokenId>": <-100..100>, ... }`. Spécifique OpenAI ; Anthropic l'ignore.

messages[].content[].image_url
string

Attachez une image à un message utilisateur. Passez un bloc de contenu `{ "type": "image_url", "image_url": { "url": ... } }`. PNG / JPEG / WebP, jusqu'à 4 par requête. Seuls les modèles avec `supportsImageInput: true` acceptent ce bloc (ex. `gpt-4o`, `claude-opus-4-7`).

messages[].content[].document_url
string

Attachez un PDF à un message utilisateur. Passez un bloc de contenu `{ "type": "document_url", "document_url": { "url": ... } }`. Jusqu'à 5 PDF par requête. Seuls les modèles avec `supportsDocuments: true` acceptent ce bloc (ex. `claude-sonnet-4-6`, `gpt-4.1`).

parallel_tool_calls
boolean
Défaut: true

Autorise le modèle à appeler plusieurs outils en parallèle dans un même tour. Mettre à `false` pour forcer les appels séquentiels. Uniquement avec `supportsTools: true` (OpenAI).

Tarifs

par 1000 tokens
0.22 credits
Entrée 0.22 · Sortie 1.1 cr/1K

Comment c'est facturé

  • Facturé au token consommé, au millième de crédit près.
  • Un message typique (500 en entrée, 150 en sortie) coûte environ —, soit 0,275 crédits.
  • Lecture du cache de prompt : — par 1K tokens (0,022 crédits).

Tarif des longs prompts

Ce modèle nous coûte plus cher au-delà d’un certain seuil, et nous répercutons ce palier plutôt que de plafonner la fenêtre ou d’augmenter le prix pour tout le monde. Le tarif ci-dessus est celui du premier palier.

Longueur du promptEntrée / 1KSortie / 1K
Moins de 272K tokens
272K tokens et plus

Le seuil compte tous les tokens en entrée, cache compris — 95K de cache plus 10K de nouveau prompt font un prompt de 105K. La sortie est tarifée selon la longueur du prompt : un long prompt avec une réponse courte paie quand même le tarif de sortie supérieur.

Scénarios concrets
Par jour
Par semaine
Par mois

Estimation sur 30 jours, pour un message type : ~500 tokens en entrée + ~150 en sortie, facturé au millième de crédit.

Une recharge de 10 000 F CFA te donne environ ~109 101 questions. Paie avec Orange Money, MTN MoMo ou M-Pesa — pas besoin de carte Visa.

Prêt à utiliser GPT-6 Luna ?

Créer votre compteDocumentation API

Crédits bonus dès la 1ère recharge · Sans carte bancaire