ForHosting KIT · Vidéo

Estimez le temps de rendu d’une vidéo

Estimez la durée d’un encodage avant de réserver une station, un nœud de rendu ou un créneau de livraison.

● BetaGratuit · dans votre navigateur

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Indiquez la durée du programme, la largeur et la hauteur de sortie, la cadence vidéo et le débit de l’encodeur mesuré à cette résolution. Le calculateur convertit la durée en nombre d’images, divise ce total par la vitesse d’encodage et fournit une durée lisible ainsi que la valeur exacte. Il affiche également le facteur temps réel afin que vous sachiez si le traitement devrait finir plus vite ou plus lentement que la lecture.

Utilisez des mesures correspondant au même travail

Une estimation utile repose sur des données cohérentes. La durée doit couvrir toute la timeline exportée, y compris les titres, le générique et les marges conservées. Saisissez la cadence de sortie réelle plutôt qu’une étiquette arrondie du projet : 29.97 et 30 images par seconde donnent des totaux différents sur un programme long. La largeur et la hauteur identifient la résolution cible. Elles ne modifient pas directement le calcul puisque le débit est déjà exprimé en images traitées par seconde, mais elles permettent de rattacher la mesure au bon format. Dans la mesure du possible, testez la vitesse avec le même codec, préréglage, échantillonnage, filtre, matériel et résolution. Si vous ne disposez que d’un test préliminaire, retenez un débit prudent plutôt que le meilleur pic observé. Le résultat reste une estimation opérationnelle : la complexité des scènes, les limites thermiques ou une charge concurrente peuvent ralentir l’encodage réel.

Comprenez le calcul et le facteur temps réel

Le calculateur multiplie d’abord la durée en secondes par la cadence de sortie afin d’obtenir le nombre d’images. Il divise ensuite ce total par le débit de l’encodeur. Un programme de deux minutes à 30 fps contient 3,600 images ; à 60 fps constants, son traitement demande environ une minute. Le facteur temps réel correspond au débit de l’encodeur divisé par la cadence du programme. Une valeur supérieure à un indique un encodage plus rapide que la lecture, une valeur égale à un correspond approximativement au temps réel, et une valeur inférieure à un signale un traitement plus lent. La résolution figure dans le résultat pour conserver le contexte du benchmark. Une durée décimale associée à une cadence fractionnaire peut produire un nombre d’images non entier. L’outil conserve cette estimation mathématique. La durée affichée est arrondie à la milliseconde et les nombres suivent un arrondi stable pour assurer la concordance entre API et navigateur.

Prévoyez une marge réaliste dans votre planning

Considérez le résultat comme le temps d’encodage actif dans les conditions de votre mesure. Une livraison complète peut aussi nécessiter le transfert des sources, la préparation du cache, l’analyse audio, la configuration multipasse, le multiplexage, les sommes de contrôle, l’envoi et le contrôle qualité. Ces étapes ne sont pas représentées par un débit en images par seconde et doivent être ajoutées séparément. Pour un lot, calculez plusieurs tâches représentatives avec le débit soutenu le plus faible attendu, puis ajoutez une marge fondée sur les variations déjà observées. Sur un système instable, une valeur prudente protège mieux une échéance qu’une moyenne favorisée par des scènes simples. Recommencez le benchmark après tout changement de résolution, codec, préréglage, réduction du bruit, mise à l’échelle, conversion colorimétrique ou accélération matérielle. L’estimation coûte $0.002 par requête API ; le parcours navigateur de niveau A exécute localement le même calcul déterministe. Aucun média n’est envoyé, seuls vos paramètres numériques sont utilisés.

Cas d’usage

Fixer une échéance d’export

Transformez la durée et le benchmark d’une station en fenêtre d’encodage avant de confirmer la livraison.

Comparer des préréglages

Saisissez les débits de plusieurs préréglages à résolution égale pour comparer leurs durées probables.

Dimensionner un lot de rendu

Estimez chaque tâche avec un débit prudent, puis ajoutez le transfert et la vérification.

Questions fréquentes

Pourquoi la cadence est-elle nécessaire en plus de la durée ?

La vitesse est mesurée en images par seconde ; la durée doit donc être convertie en images avec la cadence de sortie.

La résolution modifie-t-elle directement la formule ?

Non. Elle détermine la mesure de débit à saisir. La formule suppose que ce débit correspond à la largeur, la hauteur, au codec et aux réglages indiqués.

Que se passe-t-il si la vitesse est nulle ou négative ?

La requête renvoie une erreur de saisie, car la division par zéro est indéfinie et un débit négatif n’a pas de sens utile.

L’estimation inclut-elle l’envoi ou le contrôle qualité ?

Non. Elle couvre uniquement le traitement actif des images. Ajoutez séparément transfert, multiplexage, vérification, envoi et contrôle.

Puis-je utiliser une vitesse moyenne ?

Oui, mais un débit soutenu prudent issu d’un contenu représentatif est plus sûr pour respecter une échéance.

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/video/render-time-estimate

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/video/render-time-estimate \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}'

const res = await fetch("https://api.kit.forhosting.com/video/render-time-estimate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "duration_seconds": 120,
    "width_px": 1920,
    "height_px": 1080,
    "frame_rate_fps": 30,
    "encoder_speed_fps": 60
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/video/render-time-estimate",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "duration_seconds": 120,
    "width_px": 1920,
    "height_px": 1080,
    "frame_rate_fps": 30,
    "encoder_speed_fps": 60
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/render-time-estimate", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/render-time-estimate", 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

{
  "duration_seconds": 120,
  "width_px": 1920,
  "height_px": 1080,
  "frame_rate_fps": 30,
  "encoder_speed_fps": 60
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "video.render_time_estimate",
  "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_mb`	500
`max_minutes`	60
`max_megapixels`	3.9

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 →