ForHosting KIT · Outils pour développeurs

Estimer la longueur d'une thèse en mots et en pages

La longueur d’une thèse se planifie mieux à partir d’objectifs concrets par chapitre.

● BetaGratuit · dans votre navigateur

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Indiquez le nombre de mots prévu pour chaque partie, choisissez un interligne standard et ajoutez les pages liminaires, références ou annexes. Le calculateur additionne les mots, estime chaque chapitre et affiche la longueur totale. Ses hypothèses restent visibles afin que vous puissiez les comparer aux règles de votre établissement.

Transformez votre plan en objectifs mesurables

Énumérez les chapitres que vous comptez réellement remettre, même si leurs titres sont provisoires. Attribuez à chacun un objectif adapté à sa fonction : introduction de la problématique, synthèse des travaux antérieurs ou présentation de la méthode. Le détail révèle rapidement une revue bibliographique disproportionnée ou une discussion trop courte. Servez-vous du résultat comme point de départ, puis ajustez les valeurs après les remarques de votre direction ou l’achèvement d’une section. Un chapitre provisoire peut contenir zéro mot, mais chaque nom doit rester unique pour préserver la clarté des comparaisons.

Comprenez la conversion en pages

La pagination dépend de la police, des marges, des paragraphes, titres, citations, tableaux et figures. Aucune conversion ne prédit donc exactement le document final. L’outil applique des règles explicites : 250 mots par page en double interligne, 350 en interligne 1,5 et 500 en interligne simple. Chaque chapitre est arrondi séparément puisqu’il commence généralement sur une nouvelle page. Vérifiez l’hypothèse affichée avec les exigences de votre université concernant la police, les marges, l’espacement et les notes avant d’en faire un objectif de remise.

Ajoutez les pages absentes du décompte

Une thèse comprend aussi page de titre, déclarations, résumé, remerciements, sommaire, listes de figures, bibliographie et annexes. Ces éléments occupent parfois beaucoup de pages tout en apportant peu de mots au texte principal. Saisissez les préliminaires en pages et prévoyez séparément références et annexes ; ces valeurs sont ajoutées après l’estimation des chapitres. Consultez une thèse récente acceptée dans votre formation pour établir une première réserve, puis révisez-la lorsque la bibliographie ou les annexes s’étoffent. Les tableaux et figures intégrés ne sont pas modélisés séparément : considérez le total comme un repère de planification.

Cas d’usage

Préparer un projet de thèse

Convertissez un plan et des objectifs préliminaires en estimation claire pour une réunion.

Équilibrer les chapitres

Comparez leurs longueurs prévues et repérez les parties trop développées ou trop brèves.

Suivre la rédaction

Recalculez le plan à mesure que chapitres, références et annexes évoluent.

Questions fréquentes

Combien de mots sont prévus par page ?

Le calcul emploie 250 mots en double interligne, 350 en interligne 1,5 et 500 en simple ; la valeur choisie apparaît dans le résultat.

Pourquoi arrondir chaque chapitre séparément ?

Un chapitre commence généralement sur une nouvelle page, et son estimation reste ainsi utilisable seule.

Les préliminaires et références augmentent-ils les mots ?

Non. Leurs réserves augmentent les pages totales sans modifier la somme des mots des chapitres.

Le résultat correspondra-t-il exactement au document final ?

Non. Police, marges, titres, notes, figures et règles locales modifient la pagination ; consultez votre guide institutionnel.

Quel est le prix d’un calcul par API ?

Chaque requête API coûte $0.002. Le même estimateur déterministe fonctionne aussi dans le navigateur.

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/edu/thesis-length-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/edu/thesis-length-estimate \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"chapters":[{"name":"Introduction","word_count":3000},{"name":"Literature Review","word_count":8000},{"name":"Methodology","word_count":5000},{"name":"Results","word_count":7000},{"name":"Discussion","word_count":6000},{"name":"Conclusion","word_count":2000}]}'

const res = await fetch("https://api.kit.forhosting.com/edu/thesis-length-estimate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "chapters": [
      {
        "name": "Introduction",
        "word_count": 3000
      },
      {
        "name": "Literature Review",
        "word_count": 8000
      },
      {
        "name": "Methodology",
        "word_count": 5000
      },
      {
        "name": "Results",
        "word_count": 7000
      },
      {
        "name": "Discussion",
        "word_count": 6000
      },
      {
        "name": "Conclusion",
        "word_count": 2000
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/edu/thesis-length-estimate",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "chapters": [
        {
            "name": "Introduction",
            "word_count": 3000
        },
        {
            "name": "Literature Review",
            "word_count": 8000
        },
        {
            "name": "Methodology",
            "word_count": 5000
        },
        {
            "name": "Results",
            "word_count": 7000
        },
        {
            "name": "Discussion",
            "word_count": 6000
        },
        {
            "name": "Conclusion",
            "word_count": 2000
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/thesis-length-estimate", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"chapters":[{"name":"Introduction","word_count":3000},{"name":"Literature Review","word_count":8000},{"name":"Methodology","word_count":5000},{"name":"Results","word_count":7000},{"name":"Discussion","word_count":6000},{"name":"Conclusion","word_count":2000}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"chapters":[{"name":"Introduction","word_count":3000},{"name":"Literature Review","word_count":8000},{"name":"Methodology","word_count":5000},{"name":"Results","word_count":7000},{"name":"Discussion","word_count":6000},{"name":"Conclusion","word_count":2000}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/thesis-length-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

{
  "chapters": [
    {
      "name": "Introduction",
      "word_count": 3000
    },
    {
      "name": "Literature Review",
      "word_count": 8000
    },
    {
      "name": "Methodology",
      "word_count": 5000
    },
    {
      "name": "Results",
      "word_count": 7000
    },
    {
      "name": "Discussion",
      "word_count": 6000
    },
    {
      "name": "Conclusion",
      "word_count": 2000
    }
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "edu.thesis_length_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_items 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.

Consulter la documentation complète du KIT →