Retour à l'accueil

Documentation de l'API de Marquage d'Images par IA - Tagging et Classification Intelligents de Photos

Aperçu

L'API de Marquage d'Images par IA est un puissant service de tagging de photos par IA qui génère automatiquement des tags, des titres et des descriptions intelligents pour les images. Cette API de tagging d'images s'appuie sur des technologies avancées de vision par ordinateur et d'apprentissage automatique pour analyser le contenu des images et fournir une génération complète de métadonnées. Idéal pour les flux de travail de marquage automatique d'images, la gestion de contenu et la classification de photos.

Scénarios d'Application

L'API de Marquage d'Images par IA vous permet de mettre en œuvre efficacement le tagging de photos par IA et la génération de métadonnées dans les domaines suivants :

Clés d'API

Pour accéder à l'API de Marquage d'Images par IA, vous devez d'abord obtenir une clé d'API valide. Cette clé est utilisée pour authentifier vos requêtes et garantir un accès sécurisé à l'API.

Obtention d'une Clé d'API

  1. Accédez à la page de gestion des clés d'API : Connectez-vous au système, puis cliquez sur votre avatar d'utilisateur dans le coin supérieur droit. Dans le menu déroulant, cliquez sur "Demander une API" pour ouvrir la page de gestion des clés d'API.
API pour le marquage automatique d'images
  1. Créer une nouvelle clé : Cliquez sur "Créer une nouvelle clé", entrez un nom pour votre clé dans la boîte de dialogue contextuelle, puis cliquez sur "Créer".
Clés d'API pour le tagging de photos par IA
  1. Copiez et stockez votre clé : Notez que la clé ne sera affichée en entier qu'une seule fois. Cliquez sur l'icône de copie pour copier la clé dans votre presse-papiers, puis cliquez sur "Confirmer" pour fermer la boîte de dialogue.

Important : Ne la partagez pas avec d'autres et ne l'exposez pas dans le navigateur, le code côté client ou tout autre emplacement non sécurisé. Conservez votre clé en lieu sûr pour empêcher tout accès non autorisé.

Point de Terminaison de l'API

POST https://api.imagedescriber.app/api/v1/generate_tags

Paramètres de la Requête

En-têtes de la Requête

Corps de la Requête

L'API de tagging d'images accepte la structure de requête suivante :

{
  "image": "data:image/jpeg;base64,{image_base64_data}",
  "lang": "fr"
}

Langues Prises en Charge

Exemple de Requête (cURL)

curl --location 'https://api.imagedescriber.app/api/v1/generate_tags' \
--header 'content-type: application/json' \
--header 'authorization: Bearer votre_cle_api' \
--data '{
    "image":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQE...", 
    "lang":"fr"
}'

Exemple de Requête (Python)

import requests
import base64

def image_to_base64(image_path):
    """Convertit une image en encodage Base64"""
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return encoded_string

def generate_image_tags(api_key, image_path, lang="fr"):
    """Génère des tags d'image par IA en utilisant l'API de Marquage d'Images par IA"""
    url = "https://api.imagedescriber.app/api/v1/generate_tags"
    headers = {
        "content-type": "application/json",
        "authorization": f"Bearer {api_key}"
    }
    
    image_base64_data = image_to_base64(image_path)
    payload = {
        "image": f"data:image/jpeg;base64,{image_base64_data}",
        "lang": lang
    }

    response = requests.post(url, headers=headers, json=payload)

    if response.status_code == 200:
        result = response.json()
        tags_data = result["data"]["tags"]
        print("Tags générés:", tags_data["tags"])
        print("Titre:", tags_data["title"])
        print("Description:", tags_data["description"])
        print("Crédits restants:", result["data"]["credits"]["remaining"])
    else:
        print(f"Erreur: {response.status_code}")
        print(response.text)

# Exemple d'utilisation
api_key = "votre_cle_api"
image_path = "votre_image.jpg"

generate_image_tags(api_key, image_path)

Exemple de Requête (Next.js)

import fs from 'fs';

// Implémentation côté serveur
const buffer = await fs.readFileSync("/temp/test.jpg");
const base64Image = buffer.toString('base64');
const imageData = `data:image/jpeg;base64,${base64Image}`;

// Implémentation côté client
const file: File = /* fichier depuis un input ou un événement de dépôt */;
const arrayBuffer = await file.arrayBuffer();
const bytes = new Uint8Array(arrayBuffer);
const base64Image = btoa(String.fromCharCode.apply(null, bytes as any));
const imageData = `data:${file.type};base64,${base64Image}`;

const body = {
  "image": imageData,
  "lang": "fr"
};

const response = await fetch('https://api.imagedescriber.app/api/v1/generate_tags', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {votre_cle_api}'
  },
  body: JSON.stringify(body),
});

const result = await response.json();
console.log('Tags générés par IA :', result.data.tags.tags);
console.log('Titre généré :', result.data.tags.title);
console.log('Description générée :', result.data.tags.description);

Réponse

Corps de la Réponse (Réponse JSON)

Le service de tagging de photos par IA retourne une réponse complète contenant les tags générés, le titre, la description et les informations sur les crédits :

{
  "code": 0,
  "message": "succès",
  "request_id": "chaîne_id_requête_unique",
  "data": {
    "tags": {
      "tags": [
        "tag1",
        "tag2",
        ...
      ],
      "title": "Titre d'image concis et engageant",
      "description": "Description détaillée de l'image"
    },
    "credits": {
      "amount": "crédits consommés par cet appel",
      "remaining": "total des crédits restants après cet appel"
    }
  }
}

Limites de Requêtes

Pour assurer la stabilité et l'équité du service, chaque clé d'API est limitée à 5 requêtes par minute (300 requêtes par heure). Les requêtes dépassant cette limite seront rejetées avec le code d'erreur 1004.

Système de Crédits

Comment obtenir plus de crédits ?

Vous pouvez visiter la Page de Recharge de Crédits pour acheter des packs de crédits afin de supporter plus d'appels à l'API de tagging de photos par IA. Nous proposons divers packs pour répondre aux besoins des différents utilisateurs.

Gestion des Erreurs

Le tableau suivant liste les codes d'erreur courants, leur signification et leurs solutions :

Détails des formats d'image

Les formats d'image actuellement pris en charge incluent : JPG, JPEG, PNG, WebP. La taille maximale de l'image est de 4 Mo.

Meilleures Pratiques pour le Marquage d'Images par IA

  • Haute Résolution : Utilisez des images claires et en haute résolution pour une meilleure précision des tags de photo par IA.
  • Bon Éclairage : Des images bien éclairées produisent des tags et des descriptions plus précis.
  • Sujet Clair : Les images avec des sujets et des objets distincts génèrent des tags plus pertinents.
  • Formats Pris en Charge : Tenez-vous-en aux formats pris en charge (JPG, PNG, WebP) pour des résultats optimaux.

Cas d'Utilisation et Exemples d'Intégration

Amélioration du SEO

Utilisez l'API de tagging d'images pour générer automatiquement du texte alternatif et des méta-descriptions pour les images de votre site web :

// Améliorer le SEO des images avec des tags générés par IA
const enhanceImageSEO = async (imageElement, apiKey) => {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  canvas.width = imageElement.width;
  canvas.height = imageElement.height;
  ctx.drawImage(imageElement, 0, 0);
  
  const base64Image = canvas.toDataURL('image/jpeg');
  
  const response = await fetch('/api/v1/generate_tags', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`
    },
    body: JSON.stringify({ image: base64Image })
  });
  
  const result = await response.json();
  const { tags, title, description } = result.data.tags;
  
  // Mettre à jour les attributs de l'image pour le SEO
  imageElement.alt = description;
  imageElement.title = title;
  imageElement.setAttribute('data-tags', tags.join(', '));
};

Intégration à la Gestion de Contenu

Intégrez le tagging de photos par IA dans votre flux de travail CMS :

# Traiter en masse les images dans un système de gestion de contenu
import os
import requests
from pathlib import Path

def bulk_tag_images(directory_path, api_key):
    """Traite toutes les images d'un répertoire avec le tagging par IA"""
    image_extensions = ['.jpg', '.jpeg', '.png', '.webp']
    
    for image_path in Path(directory_path).iterdir():
        if image_path.suffix.lower() in image_extensions:
            try:
                # Générer des tags pour chaque image
                result = generate_image_tags(api_key, str(image_path))
                
                # Enregistrer les métadonnées dans un fichier associé
                metadata_path = image_path.with_suffix('.json')
                with open(metadata_path, 'w') as f:
                    json.dump(result['data']['tags'], f, indent=2)
                    
                print(f"Traité : {image_path.name}")
                
            except Exception as e:
                print(f"Erreur lors du traitement de {image_path.name}: {e}")

# Utilisation
bulk_tag_images("/chemin/vers/images", "votre_cle_api")

Contactez-nous

Si vous avez des questions ou des suggestions concernant notre API de Marquage d'Images par IA ou notre service de tagging de photos, n'hésitez pas à nous contacter via les méthodes suivantes :

Commencez à utiliser l'API de Marquage d'Images par IA dès maintenant et libérez la puissance de la classification intelligente de photos et du marquage automatique d'images !