Comment utiliser deepseek-v4-flash-vision-exp via l'API hiapi : curl, Python et une requête qui fonctionne

deepseek-v4-flash-vision-exp est un modèle texte et vision doté de capacités de raisonnement disponible sur hiapi, accessible via le point de terminaison standard compatible OpenAI : POST /v1/chat/completions. Il lit à la fois les images et le texte, prend en charge le mode JSON et l'appel de fonctions/outils, ainsi que la sortie en streaming — le tout via la même structure de requête que n'importe quel autre modèle de chat hiapi. Ce guide vous présente une requête qui fonctionne, un comportement facile à négliger (le modèle raisonne d'abord, puis répond, et le raisonnement consomme votre budget de tokens), ainsi que les pratiques de production qu'il vaut la peine de connaître avant la mise en ligne.

Ce que vous allez construire

Un script qui envoie une invite à deepseek-v4-flash-vision-exp — avec éventuellement une image — et lit la véritable réponse, pas seulement sa trace de raisonnement interne.

Prérequis : une clé API hiapi. Récupérez-la depuis la console — chacune des requêtes ci-dessous doit la transmettre dans l'en-tête Authorization.

Exemple minimal fonctionnel

curl

curl -s -X POST "https://api.hiapi.ai/v1/chat/completions" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp",
    "messages": [
      { "role": "user", "content": "Say OK and nothing else." }
    ],
    "max_tokens": 200
  }'

La réponse condensée ressemble à ceci :

{
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "role": "assistant",
        "content": "OK",
        "reasoning_content": "We need to respond exactly \"OK\" and nothing else. ..."
      }
    }
  ],
  "usage": {
    "completion_tokens": 37,
    "completion_tokens_details": { "reasoning_tokens": 34 },
    "prompt_tokens": 89,
    "total_tokens": 126
  }
}

Deux champs sont importants ici : message.content est la réponse réelle, tandis que message.reasoning_content est la chaîne de pensée interne du modèle avant qu'il ne détermine cette réponse. usage.completion_tokens_details.reasoning_tokens vous indique combien du budget max_tokens a été consommé par le raisonnement — dans cet exemple simple, 34 des 37 tokens de complétion ont servi au raisonnement avant que le modèle n'écrive « OK ».

Voilà le piège : si vous réglez max_tokens trop bas, le modèle peut dépenser tout le budget en raisonnement, ce qui donne content à null et finish_reason à "length". La même requête avec max_tokens: 10 renvoie content: null — le modèle réfléchissait encore lorsqu'il a atteint la limite. Laissez de la marge à ce modèle : au moins 150–300 tokens pour des réponses courtes, et davantage pour du contenu nécessitant une véritable profondeur de raisonnement.

Python

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={
        "Authorization": "Bearer sk-your-api-key",
        "Content-Type": "application/json",
    },
    json={
        "model": "deepseek-v4-flash-vision-exp",
        "messages": [
            {"role": "user", "content": "Say OK and nothing else."},
        ],
        "max_tokens": 200,
    },
    timeout=60,
)
resp.raise_for_status()
message = resp.json()["choices"][0]["message"]
print(message["content"])

Entrée visuelle

Vous pouvez transmettre une image aux côtés du texte en définissant content comme un tableau de segments typés — image_url accepte toute URL d'image accessible publiquement :

curl -s -X POST "https://api.hiapi.ai/v1/chat/completions" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What color is the dominant background color of this image? One word." },
          { "type": "image_url", "image_url": { "url": "https://example.com/photo.jpg" } }
        ]
      }
    ],
    "max_tokens": 200
  }'

Sur une véritable image de test, le modèle a renvoyé "Beige", et reasoning_content montre qu'il a d'abord parcouru une description visuelle avant de donner sa réponse d'un seul mot — le même schéma raisonner-puis-répondre que pour une requête purement textuelle, mais fondé sur l'image.

Mode JSON et appel d'outils

Sortie JSON structurée — ajoutez response_format: {"type": "json_object"} et mentionnez JSON dans l'invite :

{
  "model": "deepseek-v4-flash-vision-exp",
  "messages": [
    { "role": "user", "content": "Return a JSON object with keys name and age for a fictional person." }
  ],
  "response_format": { "type": "json_object" },
  "max_tokens": 300
}

message.content est renvoyé sous forme de chaîne JSON analysable ({"name": "Alex Doe", "age": 30}), tandis que reasoning_content porte toujours le brouillon du modèle — n'analysez que content, jamais reasoning_content.

Appel de fonctions/outils — transmettez un tableau tools standard de style OpenAI :

{
  "model": "deepseek-v4-flash-vision-exp",
  "messages": [
    { "role": "user", "content": "What is the weather in Tokyo right now? Use the get_weather tool." }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    }
  ],
  "max_tokens": 300
}

Le modèle répond avec finish_reason: "tool_calls" et un tableau tool_calls (contenant function.name, function.arguments sous forme de chaîne JSON, ainsi que le call_id que vous renvoyez lors du tour suivant) — la boucle standard d'appel de fonctions OpenAI fonctionne sans modification.

Considérations de production

• Prévoyez du budget max_tokens pour le raisonnement, pas seulement pour la réponse. C'est un modèle de raisonnement — chaque réponse comporte une phase reasoning_content avant le content final, et les deux puisent dans le même pool max_tokens. Vérifiez usage.completion_tokens_details.reasoning_tokens lors de vos premiers tests, calibrez une limite sûre pour vos invites, et vérifiez toujours finish_reason — "length" avec un content à null signifie que vous avez été coupé en pleine réflexion, et non que vous avez obtenu une véritable réponse.
• Le streaming fonctionne via stream: true. Contrairement à certains modèles de raisonnement de hiapi qui imposent le streaming, ce modèle prend en charge les deux modes. En mode streaming, reasoning_content et content arrivent sous forme de champs delta distincts sur le même flux de chunks — si vous souhaitez afficher « réflexion » et « réponse » comme deux états d'interface distincts, mettez-les en tampon séparément.
• Les échecs d'authentification renvoient une erreur explicite. Une clé erronée ou révoquée renvoie un HTTP 401, avec dans le corps de l'erreur "code": "permission_denied" ainsi qu'un request_id. Branchez votre traitement sur le champ code plutôt que sur une correspondance de chaîne du message, et joignez le request_id lorsque vous contactez le support.
• N'affichez pas reasoning_content comme réponse à l'utilisateur final. C'est un brouillon non structuré, pas la réponse finale — en particulier en mode JSON ou pour l'appel d'outils, seuls content (ou tool_calls) sont destinés à la consommation par la machine.
• L'entrée visuelle accepte des URL publiques, pas du base64 en ligne. image_url.url doit pouvoir être récupéré par les serveurs de hiapi ; hébergez vous-même l'image ou utilisez une URL que vous contrôlez avant d'envoyer la requête.

Lectures associées

• Page du modèle deepseek-v4-flash-vision-exp — référence complète des paramètres et tarifs en temps réel
• Documentation de l'API hiapi — authentification, autres familles de modèles et liste complète des points de terminaison
• Tarifs hiapi — tarifs par token de deepseek-v4-flash-vision-exp et de tous les autres modèles
• Guide de l'API gpt-6-astra — un second modèle de raisonnement sur hiapi, avec une forme d'intégration différente (API Responses, streaming uniquement), utile pour comparer

Questions fréquentes

deepseek-v4-flash-vision-exp prend-il en charge l'entrée visuelle ? Oui. Envoyez un content sous forme de tableau contenant un segment text et un ou plusieurs segments image_url, chacun pointant vers une URL d'image accessible publiquement. Le modèle raisonne d'abord sur l'image comme sur le texte, puis répond.

Pourquoi message.content est-il null dans ma réponse ? Votre max_tokens est trop bas : le raisonnement du modèle a épuisé tout le budget avant d'écrire la réponse. Vérifiez finish_reason — "length" avec content: null correspond à ce cas ; augmentez max_tokens et réessayez.

Prend-il en charge le mode JSON ? Oui, via response_format: {"type": "json_object"}. Le JSON arrive sous forme de chaîne dans message.content, à analyser vous-même ; reasoning_content ne fait pas partie de la sortie structurée et doit être ignoré dans ce cas.

Prend-il en charge l'appel de fonctions/outils ? Oui, avec le format standard du tableau tools d'OpenAI. Une réponse déclenchant un outil renvoie finish_reason: "tool_calls" ainsi qu'un tableau tool_calls contenant le nom de la fonction et ses arguments.

Puis-je recevoir la réponse en streaming ? Oui — définissez "stream": true et consommez les événements chat.completion.chunk. content et reasoning_content sont tous deux transmis en streaming sous forme de champs delta distincts au sein d'un même chunk.

À quoi ressemble une erreur d'authentification ? HTTP 401, avec un corps JSON contenant "type": "hiapi_error", "code": "permission_denied", un message lisible par un humain, et un request_id à transmettre au support (si le problème persiste).