Calculateur de file de podcasts
40 épisodes en retard de 55 minutes à 1,25 fois la vitesse font 1760 minutes, soit un peu plus de 29 heures d'écoute. Indiquez votre file, la durée habituelle et la vitesse que vous utilisez vraiment pour planifier votre rattrapage. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Épisodes
- 40
- Durée
- 55
- Vitesse
- 1,25
- Minutes
- 1 760
- Heures
- 29,3333333333
Une file de podcasts est un problème de temps d'écoute, pas une consultation de catalogue. Vous savez déjà combien d'épisodes non lus restent dans la file, vous connaissez déjà la durée typique de cette émission, et vous savez déjà si vous écoutez au rythme d'origine ou à une fois et demie ou au double sur le trajet. Ce calculateur transforme ces trois nombres en une seule valeur d'horloge murale : les heures d'écoute totales. Multipliez le nombre d'épisodes par la durée moyenne en minutes, divisez par la vitesse de lecture que vous allez vraiment utiliser, puis divisez par soixante. Un journal de quarante épisodes de cinquante-cinq minutes à une vitesse d'un et un quart fait un peu plus de vingt-neuf heures — plus d'une journée éveillée si vous tentiez de tout vider d'un seul tenant. Les décomptes et durées manquants, non finis ou hors plage échouent de la même façon et ne sont pas facturés.
Comment les heures de file de podcasts se calculent à partir de trois nombres
L'identité est la même que tout lecteur de podcast utilise en interne lorsqu'il estime le temps restant. La durée brute en minutes est le nombre d'épisodes multiplié par la durée moyenne d'un épisode en minutes. Le temps d'écoute en minutes est ce produit divisé par la vitesse de lecture.
Les heures sont les minutes d'écoute divisées par soixante. La vitesse de lecture est un multiplicateur positif : 1.0 est la bande originale, 1.2 et 1.5 sont les réglages courants d'Overcast et de Pocket Casts que les navetteurs utilisent pour vider la file plus vite, et 2.0 réduit l'horloge de moitié. Une valeur inférieure à 1.0 — lecture lente pour l'étude d'une langue, un entretien restauré ou un lecteur qui étire la parole — allonge l'écoute, c'est pourquoi le champ n'est pas borné à un minimum de un.
Les décomptes fractionnaires sont acceptés parce que les demi-épisodes, bandes-annonces bonus et finales en deux parties existent vraiment ; l'arithmétique n'impose pas un entier. La durée moyenne peut être n'importe quel nombre fini et positif de minutes, y compris ce magazine d'information de quarante-sept minutes et demie qui n'est ni une demi-heure nette ni une heure ronde. Ce point d'accès ne récupère pas de listes d'épisodes depuis un flux RSS ni un annuaire, ne soustrait ni générique ni publicités, et n'applique pas de fuseaux horaires.
Il répond à une seule question : si vous lisez chaque épisode listé à une vitesse constante, combien d'heures d'écoute représente cette file.
Contrat d'entrée, vitesse de lecture, champs de réponse et erreurs de validation
Les erreurs nomment toujours le champ canonique afin que le formulaire web marque le bon contrôle. Une vitesse de lecture nulle ou négative échoue parce qu'un lecteur ne peut pas diviser le temps par un taux non positif — c'est le contrat que cette capacité existe pour faire respecter, et ces échecs ne sont pas facturés. Les décomptes et durées nuls ou négatifs échouent pour la même raison : une file sans épisodes ou un épisode de durée nulle n'est pas une écoute.
Les grandeurs au-dessus des plafonds documentés échouent pour qu'une faute de frappe ne fasse pas tomber l'isolate. En cas de succès, le corps inclut les entrées répétées, minutes comme horloge d'écoute, hours comme minutes divisé par soixante, et une chaîne formula. Une émission quotidienne de cent épisodes de trente minutes à double vitesse fait vingt-cinq heures.
Où un calculateur de file de podcasts gagne sa place
Les foyers qui prévoient un rattrapage sur le trajet ont besoin d'heures pour décider si une file de quarante épisodes d'un journal tient en deux semaines de conduite ou exige une vitesse plus élevée. Les rédacteurs de lettres d'information et les éditeurs de recaps qui construisent un calendrier d'écoute ont besoin d'une conversion déterministe du nombre d'épisodes et de la durée moyenne en un budget d'horloge murale qu'ils puissent figer dans une feuille.
Les étudiants en langue qui baissent une émission d'entretiens en espagnol ou en japonais aux quatre cinquièmes de la vitesse ont besoin de la même formule avec un taux inférieur à un, pas d'un outil qui refuse en silence tout ce qui n'est pas le temps réel ou le double. Les programmateurs de clubs et les équipes d'hospitalité qui organisent une écoute thématique partagée peuvent transformer une pile d'épisodes en une horloge de bout en bout sans ouvrir une calculatrice pour chaque titre.
Gardez les trois entrées finies, conservez speed strictement positif, figez hours dans vos tests, et vous obtenez un budget d'écoute reproductible pour un plan de trajet, un calendrier éditorial, une fiche de laboratoire de langues ou un worker en bordure, sans dresser un annuaire de podcasts à vous.
Cas d’usage
Rattraper une émission hebdomadaire d'entretiens
Transformez une file de quarante épisodes de cinquante-cinq minutes à 1.25x en environ vingt-neuf heures et sachez si deux semaines de trajet suffisent.
Comparer la lecture à 1x, 1.5x et 2x
Gardez le même nombre d'épisodes et la même durée moyenne, ne changez que speed, et voyez combien d'heures d'horloge murale une bande plus rapide économise vraiment.
Planifier l'écoute sur le trajet et à la salle
Convertissez une file quotidienne d'actualités en heures que vous pouvez croiser avec le temps de conduite ou les séances de tapis, sans ouvrir une feuille pour chaque émission.
Questions fréquentes
Dans quelles unités est duration ?
Duration est la durée moyenne de l'épisode en minutes, l'unité imprimée sur la plupart des fiches de podcast. Hours n'apparaissent que dans le résultat, après conversion de l'horloge d'écoute.
Que se passe-t-il si la vitesse de lecture est nulle ou négative ?
Un lecteur ne peut pas diviser le temps par un taux non positif, et ces échecs ne sont pas facturés.
Cela récupère-t-il ma file depuis Apple Podcasts ou Spotify ?
Non. Vous fournissez vous-même le nombre d'épisodes et la durée moyenne. Le point d'accès ne récupère ni flux RSS, ni annuaires, ni files de compte.
Comment calculer le temps total pour rattraper un podcast ?
Multipliez les épisodes en retard par leur durée moyenne en minutes, divisez par la vitesse de lecture puis par 60. Ainsi, 40 épisodes de 55 minutes à 1,25 fois donnent un peu plus de 29 heures.
Les génériques et les publicités sont-ils retirés ?
Non. Chaque épisode est compté avec sa durée moyenne et à une vitesse constante. Si vous sautez souvent de longues publicités, indiquez une durée moyenne plus courte qui reflète ce que vous écoutez vraiment.
Outils associés
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
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/life/podcasts \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"episodes":40,"duration":55,"speed":1.25}'const res = await fetch("https://api.kit.forhosting.com/life/podcasts", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"episodes": 40,
"duration": 55,
"speed": 1.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/podcasts",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"episodes": 40,
"duration": 55,
"speed": 1.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/podcasts", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"episodes":40,"duration":55,"speed":1.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"episodes":40,"duration":55,"speed":1.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/podcasts", 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
{
"episodes": 40,
"duration": 55,
"speed": 1.25
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.podcasts",
"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
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_episodes | 1000000 |
max_duration | 1000000 |
max_speed | 100 |
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. |
Notes techniques
Une vitesse de lecture nulle ou négative est rejetée comme invalid_input, car un lecteur ne peut pas diviser le temps par un taux non positif. Utilisez la page dans votre navigateur sans frais, ou appelez l'API à $0.002 par requête réussie lorsqu'un calendrier de rattrapage ou une fiche de tutorat a besoin du même chiffre.
Comment les heures de file de podcasts se calculent à partir de trois nombres
La réponse répète les valeurs nettoyées de episodes, duration et speed, puis renvoie minutes comme horloge d'écoute, hours comme minutes divisé par soixante, et une chaîne formula qui reformule l'identité pour qu'une interface puisse afficher la règle à côté du nombre.
Contrat d'entrée, vitesse de lecture, champs de réponse et erreurs de validation
Envoyez un corps JSON avec trois champs obligatoires : episodes, le nombre d'épisodes non lus dans la file ; duration, la durée moyenne d'un épisode en minutes ; et speed, le multiplicateur de lecture. Les alias episode_count, n et count sont acceptés pour episodes ; average_duration, avg_duration, episode_duration et minutes pour duration ; et playback_speed, playback et rate pour speed. Chaque champ peut arriver comme nombre JSON ou comme chaîne numérique ; les booléens, objets, chaînes vides, NaN et Infinity échouent avec invalid_input. Un contrôle familier est quarante épisodes de cinquante-cinq minutes à speed 1.25, qui donnent mille sept cent soixante minutes d'écoute et 29.333333333333 heures. Les champs manquants sont invalid_input et ne sont pas facturés. Les appels API réussis utilisent le prix de base publié $0.002 ; le chemin gratuit du navigateur exécute la même fonction solve sans consommer de solde prépayé.
Où un calculateur de file de podcasts gagne sa place
Comme l'implémentation est parse pure de niveau A, chaque appel réussi coûte le prix de base publié $0.002, sans jetons de modèle ni réseau sortant, et une validation échouée ne consomme pas de solde.
Questions techniques
Comment calcule-t-on le temps d'écoute total d'une file de podcasts ?
Envoyez trois nombres : episodes, duration (minutes moyennes par épisode) et speed. L'API renvoie hours = (episodes × duration) / speed / 60, plus l'horloge d'écoute en minutes.
Combien coûte le calculateur de file de podcasts ?
L'outil du navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.