ForHosting KIT · Images

Décoder une image Base64

L’outil d’information sur les images Base64 contrôle une URI de données complète et fournit deux renseignements utiles : le type MIME déclaré dans l’en-tête et le nombre d’octets représenté par la charge encodée.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Tout est traité localement, sans consulter une URL, téléverser une image, deviner une extension ni examiner un contenu distant. La validation stricte repère les marqueurs absents, caractères interdits, remplissages incorrects, bits résiduels non canoniques et types de média étrangers aux images.

Lisez les informations déjà contenues dans l’URI

Une URI d’image Base64 réunit métadonnées et octets encodés dans une même chaîne. Son en-tête indique le type de média, tandis que sa charge représente les données binaires originales avec des caractères imprimables. La capacité ne sépare ces éléments qu’après validation de la structure entière. Le résultat contient `mime_type`, par exemple `image/png`, et `byte_length`, le nombre exact d’octets décodés. La taille n’est pas estimée d’après le seul nombre de caractères : le remplissage Base64 final est pris en compte. L’outil restitue volontairement le MIME déclaré sans prétendre reconnaître le format par sa signature binaire. Vous savez donc précisément ce que l’URI annonce et quelle taille sa charge occupe, sans modification ni réencodage silencieux.

Comprenez les refus de la validation stricte

La forme admise est une valeur complète `data:image/type;base64,payload`. Le type doit commencer par `image/`, le marqueur Base64 doit être présent et une seule virgule doit séparer l’en-tête de la charge. Celle-ci emploie l’alphabet Base64 standard, possède une longueur divisible par quatre et réserve le remplissage à la fin. Les bits inutilisés du dernier groupe sont également contrôlés. Les charges vides, espaces, caractères Base64url, paramètres supplémentaires, remplissages manquants et URL ordinaires sont refusés. Si votre source produit un fragment Base64 brut, ajoutez d’abord l’en-tête MIME approprié ; si elle produit du Base64url, convertissez-le en Base64 standard canonique.

Mesurez sans exposer ni transférer l’image

Connaître la taille décodée avant de stocker ou transmettre une image facilite les limites de téléversement, contrôles de base de données, restrictions de messages et journaux techniques. Vous pouvez écarter un élément intégré trop volumineux avant son analyse par un autre service, conserver des métadonnées cohérentes avec du HTML ou du JSON, ou comparer l’encombrement des images incorporées et liées. Le calcul est déterministe et sans réseau : la chaîne est validée, puis le nombre d’octets est déduit des groupes Base64 et du remplissage final. La capacité ne vérifie ni signature, ni dimensions, ni corruption et ne renvoie pas le binaire. Pour cela, utilisez un analyseur d’images ; pour la structure et la taille exacte, cet outil suffit.

Cas d’usage

Imposer une limite aux images intégrées

Contrôlez la taille décodée avant d’accepter une image Base64 dans une requête API, un document ou un formulaire.

Inventorier les URI de données produites

Consignez le MIME déclaré et la taille binaire des ressources générées par un éditeur, un exportateur ou une chaîne de build.

Refuser tôt les entrées incorrectes

Validez la syntaxe Base64 canonique avant de transmettre une image intégrée au stockage, au rendu ou au traitement.

Questions fréquentes

Que renvoie cette capacité ?

Elle renvoie `mime_type`, repris de l’en-tête validé, et `byte_length`, calculé depuis la charge Base64 canonique.

L’image est-elle téléversée ou récupérée ?

Non. La validation déterministe et le calcul de taille sont effectués localement, sans accès à un réseau externe.

Le MIME prouve-t-il le véritable format des octets ?

Non. Le résultat rapporte la déclaration MIME validée, sans examiner les signatures ni décoder les dimensions.

Pourquoi ma valeur Base64 a-t-elle été refusée ?

Les causes fréquentes sont un en-tête absent, un MIME non graphique, des espaces, des caractères URL-safe, un remplissage incorrect, une charge vide ou des bits résiduels non nuls.

Quel est le tarif ?

L’outil du navigateur est gratuit sur cette page. L’automatisation par API coûte $0.002 par requête.

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/image/from-base64-info

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/image/from-base64-info \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"data_uri":"https://ejemplo.com/imagen.jpg"}'

const res = await fetch("https://api.kit.forhosting.com/image/from-base64-info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data_uri": "https://ejemplo.com/imagen.jpg"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/from-base64-info",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "data_uri": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/from-base64-info", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"data_uri":"https://ejemplo.com/imagen.jpg"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"data_uri":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/from-base64-info", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "data_uri": "https://ejemplo.com/imagen.jpg"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.from_base64_info",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_chars 13981053

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Consulter la documentation complète du KIT →