L’API NeverNo
Des endpoints compatibles OpenAI et Anthropic pour les modèles ouverts privés, Claude, GPT, Gemini et Grok anonymisés, les images, la voix et les embeddings. Change l’adresse de base, garde ton code et ton agent de code.
Démarrage rapide
Crée une clé
Connecte-toi, ouvre les Réglages, puis la section API, et crée une clé. Elle n’est affichée qu’une fois : copie-la en lieu sûr. Tu peux en avoir jusqu’à 10 et révoquer chacune en un clic.
Ajoute des crédits
L’API se paie sur son propre solde API (1 crédit = 0,01 $), distinct des crédits de ton offre et de ceux achetés pour l’appli. Recharge-le depuis les Réglages, de 10 $ à 2 000 $, avec un bonus de 6 à 7 % sur les grosses recharges.
Pointe ton client vers NeverNo
Règle l’adresse de base sur
https://neverno.ai/api/v1et passe ta clé. Tout SDK ou outil compatible OpenAI fonctionne tel quel.
Adresse de base et authentification
Chaque requête part vers l’adresse ci-dessous et porte ta clé en jeton bearer, ou dans un en-tête x-api-key comme l’envoient les SDK Anthropic. Les clés commencent par nn_live_.
- Adresse de base
- https://neverno.ai/api/v1
- En-tête
- Authorization: Bearer nn_live_…
Garde ta clé sur ton serveur : ne la mets jamais dans une page web ni dans une application mobile. Une clé qui fuit se révoque à tout moment depuis les Réglages, et seule son empreinte SHA-256 est conservée chez nous.
Endpoints
Les mêmes formats de requête et de réponse qu’OpenAI (et qu’Anthropic pour /messages), et les noms de Venice pour les outils d’image.
- GET
/modelsTous les modèles avec leur type, leurs capacités (outils, vision, raisonnement, formats de réponse), leur contexte et leur prix en crédits. Public, sans clé. - POST
/chat/completionsRéponses de chat, d’un bloc ou en streaming, avec appel d’outils, sortie JSON et vision. - POST
/messagesLe format Messages d’Anthropic, pour Claude Code et les SDK Anthropic : outils, événements de streaming. - POST
/messages/count_tokensUne estimation du poids d’une requête Messages. Gratuit. - POST
/embeddingsDes vecteurs pour la recherche et la mémoire, en float ou en base64. - POST
/audio/speechSynthèse vocale, en MP3. - POST
/audio/transcriptionsTranscription d’un fichier audio de 1 Mo au plus. - POST
/images/generationsUne à quatre images à partir d’un prompt, renvoyées en base64. - POST
/images/editsUne image modifiée par une consigne, au format d’OpenAI. - POST
/image/upscaleUne image agrandie deux ou quatre fois ; l’image revient telle quelle. - POST
/image/background-removeLe sujet détouré sur fond transparent. - POST
/image/editLa même retouche que `/images/edits`, avec l’image elle-même dans la réponse.
curl https://neverno.ai/api/v1/models{ "object": "list", "data": [ { "id": "auto", "object": "model", "owned_by": "neverno", "type": "chat", … }, { "id": "z-image-turbo", "object": "model", "owned_by": "tongyi", "type": "image", "pricing": { "unit": "image", "credits": 0.325 }, … } ]}
Chat
Envoie model et messages (rôles system ou developer, user, assistant et tool, jusqu’à 2 000 messages). Avec auto, NeverNo choisit le modèle le moins cher capable de bien répondre ; sinon, indique n’importe quel modèle de chat de /models. temperature, top_p, stop et seed sont transmis aux modèles qui les acceptent et laissés de côté pour les autres (leurs supported_parameters dans /models).
Les modèles marqués vision lisent les images : passe une partie de contenu de type image_url, avec une adresse https publique (qui répond directement, 4 Mo au plus) ou une URL data:image/png;base64,… (jusqu’à 20 images, 4,5 Mo par requête). Chaque image doit être un PNG, JPEG ou WebP fixe, de 256 à 4096 pixels de côté ; elle est contrôlée selon les limites fermes et le filtre de contenu du compte avant que le modèle la voie (aucune personne qui pourrait être mineure), puis envoyée réencodée sans métadonnées. Les contrôles sont facturés avec la réponse, au même tarif. max_tokens (ou max_completion_tokens) limite la réponse ; reasoning_effort active le raisonnement sur les modèles qui le permettent, renvoyé dans reasoning_content.
Recherche web : enable_web_search à on cherche sur le web (résultats Google) avant chaque réponse, auto seulement quand la question demande des faits récents, off jamais (par défaut). enable_web_scraping: true lit les pages web dont l’adresse figure dans le dernier message. Le modèle cite les pages en [1], [2]…, numérotées comme web_search_citations (titre, url, extrait), renvoyé dans la réponse et dans le premier morceau du streaming. Les deux sont facturés en crédits au coût réel × 2,5, avec la réponse (environ 0,25 crédit par recherche). Ils peuvent aussi être passés dans venice_parameters.
curl https://neverno.ai/api/v1/chat/completions \ -H "Authorization: Bearer $NEVERNO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "auto", "messages": [{"role": "user", "content": "Explain how a VPN works in three sentences."}] }'
Streaming
Passe stream: true pour recevoir des événements serveur au format OpenAI, morceau par morceau, terminés par [DONE]. Ajoute stream_options: { "include_usage": true } pour recevoir un dernier morceau avec l’usage et sans choix.
curl -N https://neverno.ai/api/v1/chat/completions \ -H "Authorization: Bearer $NEVERNO_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "deepseek-v4-flash", "stream": true, "messages": [{"role": "user", "content": "Write a haiku about the sea."}]}'
Essaie-la
Colle une de tes clés, choisis un modèle et envoie un message : la réponse s’affiche à mesure que l’API l’envoie. Facturé en crédits comme tout appel à l’API.
Appel d’outils et sortie JSON
Passe tools (des fonctions décrites par un schéma JSON), et si tu veux tool_choice (auto, none, required ou une fonction nommée) et parallel_tool_calls. Quand le modèle appelle un outil, la réponse contient tool_calls et finish_reason vaut tool_calls ; exécute la fonction, puis renvoie le message de l’assistant suivi d’un message tool qui porte le résultat (tool_call_id), et le modèle répond à partir de ce résultat. Les modèles dont capabilities.tools est vrai dans /models le prennent en charge, auto compris ; les autres répondent par une erreur 400 claire tools_not_supported.
response_format: { "type": "json_object" } demande du JSON valide, et json_schema du JSON qui suit ton schéma, sur les modèles qui ont response_format et json_schema dans leurs capacités.
import jsontools = [{ "type": "function", "function": { "name": "get_weather", "description": "Current weather of a city", "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}, },}]messages = [{"role": "user", "content": "What is the weather in Paris?"}]reply = client.chat.completions.create(model="deepseek-v4-flash", messages=messages, tools=tools)call = reply.choices[0].message.tool_calls[0] # finish_reason == "tool_calls"args = json.loads(call.function.arguments) # {"city": "Paris"}messages += [reply.choices[0].message, {"role": "tool", "tool_call_id": call.id, "content": '{"temperature_c": 18}'}]final = client.chat.completions.create(model="deepseek-v4-flash", messages=messages, tools=tools)print(final.choices[0].message.content)
Appels d’outils en streaming
En streaming, chaque appel arrive comme l’écrit OpenAI : un premier delta avec son index, son id, son type et le name de la fonction, puis les arguments en morceaux sous le même index, et un dernier morceau avec finish_reason: "tool_calls".
data: {"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}], …}data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_8f…","type":"function","function":{"name":"get_weather","arguments":""}}]}, …}]}data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"city\":"}}]}, …}]}data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\"Paris\"}"}}]}, …}]}data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}], …}data: [DONE]
Messages Anthropic et Claude Code
POST /messages parle le format d’Anthropic : system, blocs de texte, d’image, tool_use et tool_result, tools avec input_schema, tool_choice, stop_sequences, thinking, et les événements de streaming (message_start, content_block_start, text_delta, input_json_delta, content_block_stop, message_delta, message_stop, ping). La clé va dans x-api-key ou Authorization: Bearer ; anthropic-version et anthropic-beta sont acceptés.
Les noms de modèles Claude (claude-sonnet-…, claude-opus-…, claude-haiku-…, avec ou sans date) sont servis par le modèle Claude de la même famille listé dans /models, et tout autre identifiant de modèle de chat du catalogue fonctionne aussi : deepseek-v4-pro ou glm-5.2 par le même endpoint coûtent bien moins cher. Le modèle qui a répondu est indiqué dans l’en-tête X-NeverNo-Model. Les outils serveur propres à Anthropic (sa recherche web, son exécution de code) sont laissés de côté ; les outils de ton client fonctionnent normalement.
import osimport anthropicclient = anthropic.Anthropic(base_url="https://neverno.ai/api", api_key=os.environ["NEVERNO_API_KEY"])message = client.messages.create( model="claude-sonnet-4-5", # served by the Claude Sonnet model in /models max_tokens=1024, messages=[{"role": "user", "content": "Explain how a VPN works in three sentences."}],)print(message.content[0].text)
Claude Code
Pointe Claude Code vers NeverNo avec deux variables d’environnement, puis lance claude comme d’habitude. Il appelle https://neverno.ai/api/v1/messages.
export ANTHROPIC_BASE_URL="https://neverno.ai/api"export ANTHROPIC_AUTH_TOKEN="nn_live_…"# optional: the models Claude Code usesexport ANTHROPIC_MODEL="claude-sonnet-4-5"export ANTHROPIC_SMALL_FAST_MODEL="claude-haiku-4-5"claude
ANTHROPIC_MODEL et ANTHROPIC_SMALL_FAST_MODEL choisissent les modèles (un nom Claude, ou n’importe quel identifiant de modèle de chat de /models). Chaque appel est facturé en crédits comme tout autre appel d’API. Le cache de prompt d’Anthropic est transmis : les points cache_control que pose Claude Code (système, résultats d’outils, derniers messages ; quatre au plus, ttl 5m ou 1h) passent aux modèles Claude, et usage rapporte cache_creation_input_tokens et cache_read_input_tokens. Une écriture en cache est facturée 1,25 × le prix d’entrée (2 × avec ttl: "1h"), une lecture 0,025 à 0,1 × selon le modèle (/models donne chaque prix) : sur une longue session, chaque tour coûte une fraction de son prix sans cache. Sur l’endpoint OpenAI, place cache_control sur une partie texte d’un message system, user ou tool, ou à la racine de la requête pour un point automatique ; prompt_tokens_details montre alors cached_tokens et cache_write_tokens.
Agents de code et outils
Tout outil qui accepte un fournisseur compatible OpenAI fonctionne avec l’adresse de base et une clé ; les modèles qui ont les outils dans /models tiennent le travail d’agent.
| Outil | Réglage |
|---|---|
| Claude Code | ANTHROPIC_BASE_URL=https://neverno.ai/api et ANTHROPIC_AUTH_TOKEN=nn_live_… (voir plus haut). |
| Cline, Roo Code | Fournisseur d’API « OpenAI Compatible », adresse de base https://neverno.ai/api/v1, ta clé, un identifiant de modèle comme deepseek-v4-pro. Ou le fournisseur « Anthropic » avec l’adresse personnalisée https://neverno.ai/api. |
| Cursor | Settings › Models : ajoute l’identifiant du modèle, active « Override OpenAI Base URL » avec https://neverno.ai/api/v1 et colle ta clé comme clé d’API OpenAI. |
| Aider | OPENAI_API_BASE=https://neverno.ai/api/v1 et OPENAI_API_KEY=nn_live_…, puis aider --model openai/deepseek-v4-pro. |
| Continue | Dans config.yaml : provider: openai, apiBase: https://neverno.ai/api/v1, ta apiKey et l’identifiant model ; qwen3-embedding-0.6b comme modèle d’embeddings. |
| OpenCode | Un fournisseur @ai-sdk/openai-compatible avec baseURL: https://neverno.ai/api/v1, ta clé et les identifiants de modèles voulus. |
Les agents de code renvoient toute leur session à chaque tour : une longue session coûte plus cher par appel. Les modèles moins chers (deepseek-v4-flash, glm-5.2, deepseek-v4-pro) gardent la note basse.
Génération d’images
Envoie un prompt et, si tu veux, un model (par défaut z-image-turbo). Les images reviennent uniquement en b64_json : elles ne sont jamais stockées chez nous, il n’y a donc pas d’URL à récupérer plus tard. Décode le base64 et enregistre le fichier toi-même.
Chaque image fait environ un mégapixel : la size demandée est rapprochée du format pris en charge le plus proche (1:1, 4:3, 3:4, 3:2, 2:3, 16:9, 9:16, 21:9), et la taille réellement produite est indiquée dans la réponse.
curl https://neverno.ai/api/v1/images/generations \ -H "Authorization: Bearer $NEVERNO_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "z-image-turbo", "prompt": "A lighthouse at dawn, 35mm photo", "size": "1024x1024"}' \ | jq -r '.data[0].b64_json' | base64 --decode > lighthouse.webp
Champs de la requête
- prompt
- Obligatoire. Jusqu’à 1 500 caractères.
- model
- Un identifiant de modèle d’image de
/models(typeimage). Par défautz-image-turbo. - n
- Nombre d’images, de 1 à 4. Par défaut 1.
- size
1024x1024,832x1216,1792x1024… ouauto(carré). Rapport jusqu’à 3:1.- response_format
b64_jsonuniquement (par défaut).- output_format
webp(par défaut),pngoujpeg.- negative_prompt
- Facultatif, jusqu’à 500 caractères. Utilisé par les modèles qui le prennent en charge.
- seed
- Entier facultatif, pour reproduire un résultat.
Réponse
Le format d’OpenAI (created, data[].b64_json), avec en plus le model, la size produite, l’output_format et les credits débités.
{ "created": 1793361600, "data": [{ "b64_json": "UklGRk4vAABXRUJQVlA4…", "seed": 81726354 }], "model": "z-image-turbo", "size": "1024x1024", "output_format": "webp", "credits": 0.325}
Embeddings, voix et outils d’image
/embeddings renvoie les vecteurs du modèle de la mémoire de NeverNo (qwen3-embedding-0.6b, 1 024 valeurs, jusqu’à 128 entrées par requête) ; dimensions les raccourcit et encoding_format: "base64" est compris. Les noms de modèles d’OpenAI sont acceptés et servis par ce même modèle.
/audio/speech lit jusqu’à 4 096 caractères en MP3 avec les voix de l’application : tts-kokoro (par défaut, plusieurs langues), tts-xai, tts-qwen3, tts-inworld et tts-minimax ; voice est un nom de voix listé dans /models, et les noms d’OpenAI (tts-1, alloy, nova…) sont associés à Kokoro. /audio/transcriptions prend un file en multipart de 1 Mo au plus (WebM, Ogg, MP4/M4A, MP3, WAV, AAC), facturé à sa durée, et répond en json, text ou verbose_json.
vectors = client.embeddings.create( model="qwen3-embedding-0.6b", input=["NeverNo keeps nothing.", "The sky is blue."], dimensions=512,)print(len(vectors.data[0].embedding)) # 512
Outils d’image
Envoie image en base64, en URL data ou en adresse https publique (ou en fichier multipart). L’image est d’abord contrôlée selon les limites fermes, et chaque consigne de retouche est relue. /image/* renvoie l’image elle-même (PNG par défaut, output_format pour changer), /images/edits renvoie b64_json.
Tarifs en crédits
| Modèle ou outil | Unité | Crédits |
|---|---|---|
qwen3-embedding-0.6b | 1 M de tokens | 1,5 |
tts-kokoro | 1 000 caractères | 0,15 |
tts-xai | 1 000 caractères | 2,25 |
tts-qwen3 | 1 000 caractères | 3 |
tts-inworld | 1 000 caractères | 7,5 |
tts-minimax | 1 000 caractères | 15 |
whisper-large-v3-turbo | minute d’audio | 0,03 |
/image/upscale | image | 0,15 |
/image/background-remove | image | 0,15 |
/image/edit | image | 0,325 |
Tarifs en crédits
1 crédit = 0,01 $. L’API est facturée au coût réel du modèle appelé, multiplié par 1,5 pour les modèles ouverts comme pour les modèles fermés (Claude, GPT, Gemini, Grok) et par 2,5 pour les images, sans abonnement obligatoire. Elle se paie sur un solde API séparé : les crédits inclus dans une offre et ceux achetés pour l’appli ne sont jamais dépensés par l’API, et l’API ne les dépense jamais.
Les recharges de 10 $, 25 $, 100 $, 500 $ ou 2 000 $ (n’importe quel montant de 10 $ à 2 000 $) ont un bonus de volume calculé sur le montant payé en un seul paiement : +6 % dès 100 $, +7 % dès 500 $, utilisable sur les modèles ouverts et les images. Les taxes sont comprises dans le prix, payé dans ta devise locale.
Crédit de départ : à la création de ta première clé API, ton compte reçoit 1 $ une seule fois, utilisable sur les modèles ouverts et les images seulement (un budget quotidien est partagé entre les nouveaux comptes, il peut donc être épuisé). L’abonnement « Dev », 25 $ par mois, ajoute 1 $ de crédit API par jour, pour les modèles ouverts et les images seulement, non reporté au lendemain ; sa limite de requêtes est celle de Pro+.
Avant un appel, le maximum qu’il peut coûter est réservé sur ton solde ; une fois terminé, tu paies le montant réel et le reste revient. Un appel qui échoue chez le fournisseur est remboursé.
Ce qu’un appel a coûté est renvoyé, en crédits, dans l’en-tête X-NeverNo-Credits des réponses non diffusées de /chat/completions et /messages (par exemple X-NeverNo-Credits: 0.8421, arrondi à 4 décimales) ; une réponse diffusée envoie ses en-têtes avant la fin et n’en porte donc pas. Quand une réponse est refusée, elle peut être offerte dans des limites : l’en-tête indique alors 0 et rien n’est débité.
Modèles Claude : les tokens lus dans le cache de prompt d’Anthropic coûtent 0,025 à 0,1 × le prix d’entrée selon le modèle (0,05 × pour Opus et Sonnet) et les tokens qui y sont écrits 1,25 × (2 × pour un cache d’une heure) ; /models liste cache_read_credits et cache_write_credits. La réservation suppose le pire cas (tout écrit), le règlement suit ce que le fournisseur rapporte.
Les modèles OpenAI écrivent tout le prompt dans leur cache à chaque appel et le facturent 1,25 × le prix d’entrée : leur input_credits dans /models l’inclut déjà ; les tokens relus coûtent cache_read_credits.
Modèles de chat, crédits par million de tokens
| Modèle | Confidentialité | Outils | Entrée | Sortie |
|---|---|---|---|---|
NeverNo Uncensoredneverno-uncensored | privé | — | 31,65 | 142,425 |
DeepSeek V4 Flashdeepseek-v4-flash | privé | ✓ | 14,4008 | 28,8015 |
GLM 5.3 Flashglm-5.3-flash | privé | ✓ | 23,7375 | 79,125 |
Qwen 3.5 35Bqwen-3.5-35b | privé | ✓ | 22,155 | 158,25 |
Mistral Small 3.2mistral-small-3.2 | privé | ✓ | 11,8687 | 31,65 |
GLM 5.2glm-5.2 | privé | ✓ | 221,55 | 696,3 |
DeepSeek V4 Prodeepseek-v4-pro | privé | ✓ | 205,725 | 411,45 |
Euryale 70Beuryale-70b | privé | — | 134,5125 | 134,5125 |
Kimi K3kimi-k3 | privé | ✓ | 451,0125 | 2 373,75 |
Claude Fable 5.2claude-fable-5.2 | anonymisé | ✓ | 1 266 | 6 330 |
Claude Opus 5.5claude-opus-5.5 | anonymisé | ✓ | 633 | 3 165 |
Claude Sonnet 5.5claude-sonnet-5.5 | anonymisé | ✓ | 316,5 | 1 582,5 |
Claude Haiku 5.5claude-haiku-5.5 | anonymisé | ✓ | 15,825 | 79,125 |
GPT-6 Astragpt-6-astra | anonymisé | ✓ | 1 978,125 | 7 912,5 |
GPT-6.1 Solgpt-6.1-sol | anonymisé | ✓ | 395,625 | 1 582,5 |
GPT-6.1 Terragpt-6.1-terra | anonymisé | ✓ | 197,8125 | 791,25 |
Gemini 4 Argongemini-4-argon | anonymisé | ✓ | 316,5 | 1 582,5 |
Grok 4.7grok-4.7 | anonymisé | ✓ | 316,5 | 949,5 |
auto est facturé au prix du modèle qu’il choisit pour chaque requête. Les modèles anonymisés sont appelés sans ton identité, mais les règles de leurs éditeurs s’appliquent toujours.
Modèles d’image, crédits par image
| Modèle | Par image |
|---|---|
Z-Image Turboz-image-turbo | 0,325 |
FLUX 3 Kleinflux-3-klein | 0,325 |
NeverNo Uncensoredneverno-uncensored-image | 0,325 |
Z-Imagez-image | 1,6 |
Qwen Image 2.1 Turboqwen-image-2.1-turbo | 3,5 |
Qwen Image 3.0 Proqwen-image-3-pro | 10 |
FLUX 3flux-3 | 12 |
Nano Banana 2.1nano-banana-2.1 | 8,4 |
GPT Image 2.6gpt-image-2.6 | 10,925 |
GPT Image 2.6 Flaregpt-image-2.6-flare | 10,925 |
Muse Imagemuse-image | 2,5 |
Limites de requêtes
Chaque compte dispose d’un nombre de requêtes API par période glissante de 24 heures, selon son offre. Au-delà, les appels reçoivent une erreur 429 jusqu’à ce que la fenêtre avance.
| Offre | Requêtes par 24 h |
|---|---|
| Gratuit | 500 |
| Pro | 5 000 |
| Pro+ | 20 000 |
| Max | 50 000 |
Chaque appel compte pour une requête, quel que soit le nombre de tokens ou d’images ; `/messages/count_tokens` ne compte pas. Une courte limite par minute s’applique aussi (429 avec `Retry-After`).
Erreurs
Les erreurs suivent le format d’OpenAI, pour que les bibliothèques clientes affichent le message tel quel : { "error": { "message", "type", "code" } }.
| Statut | Code | Signification |
|---|---|---|
| 400 | invalid_request | Un champ manque ou est mal formé ; le message précise lequel. |
| 400 | invalid_size | La taille d’image est illisible, ou son rapport dépasse 3:1. |
| 400 | unsupported_response_format | Les images sont renvoyées uniquement en b64_json. |
| 400 | model_no_vision | Ce modèle de chat ne lit pas les images. |
| 400 | tools_not_supported | Ce modèle de chat ne prend pas en charge l’appel d’outils : choisis-en un qui a tools dans ses capacités. |
| 400 | response_format_not_supported | Ce modèle de chat ne peut pas suivre le response_format demandé. |
| 400 | model_rejected_request | Le modèle a refusé les options de la requête ; rien n’a été facturé. |
| 400 | context_length_exceeded | Le prompt dépasse le contexte du modèle. |
| 400 | invalid_image | Une image est illisible : PNG, JPEG ou WebP, de 256 à 4096 pixels de côté (image_too_small, image_too_large), en URL data ou adresse https publique. |
| 400 | content_policy_violation | La demande franchit les limites fermes qui s’appliquent à tous. |
| 401 | invalid_api_key | Clé absente, inconnue ou révoquée. |
| 402 | insufficient_credits | Pas assez de crédits pour cette requête. |
| 403 | content_filtered | Bloqué par les réglages de contenu du compte (confirmation d’âge et filtre, dans les Réglages). |
| 404 | model_not_found | Identifiant de modèle inconnu : voir /models. |
| 413 | too_large | Corps de requête trop volumineux. |
| 422 | image_refused | Une image franchit les limites fermes (aucune personne qui pourrait être mineure) ou le filtre de contenu du compte. |
| 422 | request_refused | La requête sort de ce que NeverNo traite : voir la politique d’usage acceptable. |
| 429 | rate_limited | Limite quotidienne de requêtes atteinte. |
| 502 | provider_error | Le fournisseur du modèle a échoué ; rien n’est facturé pour ce qui n’a pas été livré. |
| 503 | image_check_unavailable | Une image n’a pas pu être contrôlée ; réessaie dans un instant. |
| 503 | safety_check_unavailable | La requête n’a pas pu être contrôlée ; réessaie dans un instant. |
{ "error": { "message": "Not enough credits for this request. Buy credits in NeverNo.", "type": "insufficient_quota", "code": "insufficient_credits" }}
Confidentialité
Nous n’enregistrons ni ne conservons tes prompts, tes messages, les réponses ou les images. Rien d’une requête ne sert à entraîner un modèle. Les modèles privés tournent chez des fournisseurs qui ne gardent rien ; les modèles anonymisés sont appelés sans ton identité.
Ce que nous gardons, c’est ce qu’exige la facturation : l’heure de chaque appel, le modèle et les crédits débités, et la dernière utilisation de chaque clé.
Les mêmes limites fermes s’appliquent à tous, par l’API comme dans l’application : rien qui implique des mineurs, rien sur des personnes réelles sans leur accord, aucune aide réelle pour nuire gravement à autrui.
Construis avec NeverNo
Crée une clé dans les Réglages et fais ton premier appel en une minute.
Créer une clé API