ForHosting KIT · Images

Agrandir une image

Ce point d'accès prend une image et la rééchantillonne vers des dimensions en pixels plus grandes, pour les cas où un petit fichier doit tenir dans une mise en page conçue pour un plus grand.

Temporairement retiréepar requête + par image$0.061

Cette tâche n'est pas disponible pour le moment et ne peut donc pas être achetée. Rien n'est facturé.

Voir l’API

Utilisez-le depuis Web API uniquementAPIE-mailTelegramApp bientôt

C'est un agrandissement ordinaire de bonne qualité, pas un rehausseur qui reconstruit le détail : il n'ajoute pas d'information absente de l'original, si bien qu'une photo agrandie paraît plus floue qu'une photo prise à cette taille. Il n'est pas disponible pour l'instant et n'accepte aucune tâche ; la note ci-dessous explique pourquoi, et le point d'accès et le prix affichés ici sont ceux qu'il utiliserait s'il revient.

Ce qu'un agrandissement ordinaire peut et ne peut pas faire

Agrandir une image, c'est la rééchantillonner : les pixels existants sont répartis sur une toile plus grande et les vides sont comblés par interpolation. Cela suffit pour qu'une petite image atteigne une taille exigée, mais l'interpolation ne peut pas ajouter d'information que la source n'a jamais enregistrée. Les bords fins s'adoucissent, le petit texte se brouille et la texture s'aplatit à mesure que le facteur grandit : un agrandissement 4x le montre plus qu'un 2x. Tout outil qui prétend « restaurer » un détail perdu décrit un modèle plus lourd, fondé sur GPU, que ce point d'accès n'exécute pas.

Pourquoi cet outil n'est pas disponible en ce moment

Un agrandisseur qui reconstruit réellement le détail exige un modèle neuronal de super-résolution, et ceux-ci ont besoin d'un GPU pour tourner à un coût raisonnable. La plateforme derrière ce point d'accès ne propose que du CPU ; la version honnête de cet outil — celle qui ne survend pas ce qu'un rééchantillonnage sur CPU peut donner — est donc encore en refonte. D'ici là, le point d'accès n'accepte aucune tâche, et rien n'est facturé pour une tâche qui ne peut pas s'exécuter.

Quand un agrandissement ordinaire reste utile

Rééchantillonner vers une taille plus grande a de vrais usages même sans détail ajouté : atteindre les dimensions minimales en pixels d'un gabarit, imprimer un petit visuel à une taille physique fixe, ou uniformiser un ensemble d'images de tailles diverses vers une seule résolution. Dans chaque cas, la valeur est le changement de taille, pas une netteté nouvelle : le résultat ressemblera à l'original à plus grande échelle, ce qui, pour bien des tâches de mise en page et d'impression, est exactement ce qu'il faut.

Formats et fonctionnement prévu

Les formats matriciels courants seraient acceptés en entrée, et vous choisiriez le format de sortie. À son retour, l'outil fonctionnerait de façon asynchrone : envoyez l'image et un facteur cible, recevez un task_id et obtenez le fichier agrandi par lien signé dès qu'il est prêt — utile quand l'agrandissement est une étape d'une tâche plus large, comme préparer un catalogue hétérogène à une taille minimale commune.

Cas d’usage

Atteindre la taille minimale d'un gabarit

Un gabarit de fiche exige une taille minimale en pixels et une image source plus petite est agrandie pour tenir, en acceptant que le résultat soit plus flou plutôt que plus net.

Impression à taille fixe

Un petit logo ou visuel est agrandi vers les dimensions en pixels qu'une mise en page d'impression attend pour une taille physique donnée.

Uniformiser un ensemble hétérogène

Un lot d'images de tailles différentes est rééchantillonné vers une seule résolution commune avant la mise en page, sans prétendre ajouter du détail.

Remplir un cadre plus grand

Un petit avatar est agrandi pour être réutilisé dans un cadre plus grand, dans les cas où un résultat plus flou est acceptable.

Questions fréquentes

Comment agrandirais-je une image via l'api ?

Cet outil n'est pas encore disponible. À son retour, vous feriez un POST sur /image/upscale avec l'image source et un facteur cible, 2x ou 4x, et recevriez un task_id ainsi que l'image agrandie par webhook ou lien signé.

Quelle est la différence entre 2x et 4x ?

2x double la largeur et la hauteur, 4x les quadruple. Comme un agrandissement ordinaire ne peut pas ajouter de détail, plus le facteur est élevé, plus le résultat paraît flou.

Cela rend-il nette une photo floue ?

Non. Un agrandissement ordinaire rééchantillonne l'image vers une taille plus grande ; il ne peut pas récupérer un détail jamais capté, donc une source floue ou très compressée reste molle : plus grande, pas plus nette.

Y a-t-il une offre gratuite pour l'api d'agrandissement d'image ?

Il n'y a pas d'offre gratuite — les offres gratuites sont détournées et ralentissent tout le monde. L'accès fonctionne avec un solde ForHosting KIT prépayé : rechargez à partir de $10.00 (il n'expire jamais) et chaque requête est facturée à son prix publié, si bien qu'un appel sans solde renvoie HTTP 402. Pas d'abonnement, pas de jetons ni de crédits inventés, et une tâche échouée n'est jamais facturée.

Combien coûte l'agrandissement d'une image ?

$0.061 par requête plus $0.0041 par image, et seules les tâches terminées sont facturées.

L'api d'agrandissement d'image est-elle déjà en ligne ?

Non. Elle est temporairement retirée le temps d'être refondue pour ne pas promettre un détail qu'un rééchantillonnage sur CPU ne peut pas donner. Le point d'accès et le prix affichés ici sont ceux qu'elle utiliserait si elle revient.

Quels formats d'image pourrais-je agrandir ?

Les formats matriciels courants seraient acceptés en entrée, et vous choisiriez le format de sortie pour le résultat agrandi.

Pourrais-je agrandir un grand lot d'images d'un coup ?

Oui, vous combineriez ce point d'accès avec l'API de traitement par lots pour agrandir de nombreuses images en un seul appel, chacune facturée séparément.

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/upscale

One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/image/upscale \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image":"https://example.com/photo.jpg"}'

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

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/upscale",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "image": "https://example.com/photo.jpg"
},
)
task_id = res.json()["task_id"]

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

body := bytes.NewBufferString(`{"image":"https://example.com/photo.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/upscale", 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

{
  "image": "https://example.com/photo.jpg"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.upscale",
  "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.061

par image$0.0041

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

Limites

`max_mb`	15
`max_megapixels`	12

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.
`501`	`coming_soon`	Cette capacité arrive bientôt : elle n’accepte pas encore de tâches.

Consulter la documentation complète du KIT →