ForHosting KIT · Outils pour développeurs

Générez une phrase secrète mémorable avec une graine

Ce générateur transforme une graine privée en une suite reproductible de mots anglais simples.

● BetaGratuit · dans votre navigateur

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Vous choisissez au moins trois mots et un séparateur, puis recevez la phrase complète ainsi que chaque mot séparément. Le procédé étant déterministe, une graine, un nombre et un séparateur identiques donnent toujours le même résultat dans les environnements compatibles. L’outil convient aux tests reproductibles, aux procédures de récupération contrôlées et aux systèmes qui doivent dériver une valeur lisible sans la stocker. La graine demeure le secret essentiel : toute personne capable de la deviner peut reproduire le résultat.

Comprendre la génération déterministe

Un générateur classique tire de nouveaux caractères aléatoires à chaque exécution ; une requête répétée produit donc une autre réponse. Cet outil répond à un besoin différent. Il convertit la graine fournie en un état interne fixe, fait progresser cet état pour chaque mot demandé et associe chaque valeur à une entrée d’une liste sélectionnée de 256 mots anglais distincts en minuscules. Les mots retenus sont ensuite reliés par le séparateur que vous indiquez. Aucun appel réseau, aucune horloge système, aucune source aléatoire de l’environnement et aucun dictionnaire externe susceptible de changer n’interviennent. Des entrées identiques reproduisent ainsi exactement la même phrase, ordre et ponctuation compris. La réponse contient également les mots sous forme de liste, pratique pour les afficher, les prononcer ou valider chaque élément séparément. Le nombre de mots doit être un entier compris entre 3 et 24, la graine ne doit pas être vide et le séparateur doit compter entre un et trois caractères. Ces bornes garantissent une opération prévisible et limitée.

Choisir une graine adaptée à la sécurité attendue

Le déterminisme est utile, mais il modifie le modèle de sécurité. La phrase n’est difficile à reproduire que si la graine est difficile à deviner. Un identifiant public, une adresse électronique, une date de naissance, un nom de projet ou une citation connue ne constituent pas une bonne graine secrète, même si les mots obtenus semblent inhabituels. Un attaquant peut essayer des valeurs probables avec le même algorithme et comparer la phrase dérivée. Pour un usage sensible, partez d’un secret créé et conservé par un dispositif fiable de gestion des secrets, puis gardez-le séparé de la phrase produite. Ajouter des mots allonge le résultat affiché, sans réparer une graine faible ou divulguée. L’outil n’ajoute pas non plus de nouvel aléa à chaque exécution, ne renouvelle pas les identifiants, ne contrôle pas une politique de mot de passe et ne protège pas la graine après son envoi à votre application. Considérez le résultat comme une dérivation déterministe, et non comme une preuve d’entropie. Pour obtenir un identifiant indépendant à chaque fois, utilisez plutôt un générateur aléatoire cryptographiquement sûr ou Diceware.

Profiter de la répétabilité sans mauvaise surprise

Une phrase issue d’une graine est utile lorsque des tests, des jeux de données, des outils hors ligne ou des procédures de récupération doivent partager une valeur lisible sans se la transmettre directement. Consignez avec le processus le nombre exact de mots, le séparateur, la version de l’algorithme et les règles de traitement de la graine. Toute modification d’entrée change la phrase ; modifier uniquement le séparateur conserve les mots choisis mais transforme la chaîne finale. Avant d’utiliser le résultat comme identifiant, vérifiez que le service destinataire accepte sa longueur et sa ponctuation. Certains systèmes refusent les espaces, les séparateurs répétés ou les valeurs longues. Ne placez jamais la graine dans une URL, des données analytiques, un dépôt de code, une capture d’écran, une demande d’assistance ou un journal ordinaire. Pour l’automatisation, utilisez le champ de phrase si une chaîne unique est nécessaire, ou la liste lorsque le traitement suivant exige des éléments structurés. Chaque requête API coûte $0.002. Réservez les graines connues et non secrètes aux tests, et gardez celles de production hors du code et de la documentation.

Cas d’usage

Identifiants de test reproductibles

Dérivez des valeurs stables et lisibles depuis des graines de test explicitement non secrètes sans stocker de nombreuses chaînes.

Phrases de récupération contrôlées

Recréez une phrase mémorable lorsqu’une procédure autorisée peut fournir de façon sûre la même graine et les mêmes réglages.

Résultat cohérent localement et à distance

Produisez la même suite dans le navigateur et via l’API sans dépendre d’un service aléatoire partagé.

Questions fréquentes

La phrase générée est-elle aléatoire ?

Non. Elle est déterministe : la même graine et le même nombre sélectionnent les mêmes mots. Employez un générateur sûr pour un nouvel identifiant indépendant.

Que se passe-t-il avec moins de trois mots ?

La requête échoue pour cause d’entrée non valide. Le nombre accepté va de 3 à 24 mots.

Puis-je utiliser une espace comme séparateur ?

Oui. Le séparateur peut contenir un à trois caractères, y compris une seule espace.

Une phrase plus longue compense-t-elle une graine faible ?

Non. Quiconque devine la graine peut reproduire tout nombre demandé. Protégez-la et rendez-la imprévisible.

Les mêmes entrées fonctionnent-elles partout ?

Oui. L’algorithme et la liste sont fixes et ne dépendent ni du réseau, ni de l’horloge, ni d’une source aléatoire.

Quel est le coût d’une requête API ?

Chaque requête API coûte $0.002. Le navigateur peut exécuter localement la même logique pure.

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/security/passphrase-generate-seeded

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/security/passphrase-generate-seeded \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"word_count":6,"seed":"correct horse workshop 2026"}'

const res = await fetch("https://api.kit.forhosting.com/security/passphrase-generate-seeded", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "word_count": 6,
    "seed": "correct horse workshop 2026"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/security/passphrase-generate-seeded",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "word_count": 6,
    "seed": "correct horse workshop 2026"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/passphrase-generate-seeded", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"word_count":6,"seed":"correct horse workshop 2026"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"word_count":6,"seed":"correct horse workshop 2026"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/passphrase-generate-seeded", 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

{
  "word_count": 6,
  "seed": "correct horse workshop 2026"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "security.passphrase_generate_seeded",
  "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.

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 →