Générer un slug d’URL courte
Indiquez une URL longue et une graine et obtenez un code court qui ne change jamais : la page de l'exemple avec la graine tenant-acme-v1 donne toujours rTEr1Ff, sept caractères base62 par défaut. Rien n'est consulté ni stocké, et aucun lien actif n'est créé. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Adresse web
- https://example.com/docs/guide
- Graine
- tenant-acme-v1
- Longueur
- 7
- Slug
- rTEr1Ff
- Alphabet
- base62
- Chemin court
- /rTEr1Ff
Les raccourcisseurs d’URL ont besoin de codes de chemin courts et opaques qui renvoient vers une cible longue sans révéler la structure du lien. Les équipes qui construisent leur propre raccourcisseur—ou allouent des codes vanity hors ligne avant l’écriture—ont besoin d’une fonction déterministe : la même URL cible et la même graine de locataire doivent toujours produire le même slug de la longueur choisie, afin que les nouvelles tentatives et les rédacteurs multi-région n’inventent jamais de chaînes aléatoires en collision pour le même lien logique. Cette capacité accepte une URL cible, une graine (espace de noms, secret ou clé de locataire) et une longueur optionnelle (sept par défaut, minimum quatre), puis développe un mélange pur de style FNV d’URL plus graine en chiffres base62 tirés de 0-9, A-Z et a-z.
Comment le slug base62 du raccourcisseur à graine est construit
Un slug de raccourcisseur n’est pas un slug de titre lisible par un humain. C’est un jeton opaque dans un alphabet compact qui convient aux codes QR, aux SMS et aux emballages imprimés tout en offrant un espace combinatoire suffisant pour des millions de liens. Cet outil utilise l’alphabet classique base62 de dix chiffres, vingt-six lettres majuscules et vingt-six minuscules—soixante-deux symboles qui circulent en sécurité dans les segments de chemin sans encodage percent.
Le générateur concatène l’URL cible, un séparateur NUL et votre graine, puis exécute des tours FNV-1a 32 bits salés par compteur qui développent cinq chiffres base62 par tour jusqu’à atteindre la longueur demandée. Comme le mélange est une arithmétique pure sur les codes de caractères, les mêmes entrées donnent toujours le même slug sous Node et dans le navigateur.
La graine rend les systèmes multi-locataires sûrs : deux locataires qui raccourcissent la même URL marketing avec des graines différentes obtiennent des codes différents, de sorte que les espaces de noms publics partagés ne révèlent pas que deux organisations pointaient vers la même destination.
La longueur par défaut est de sept caractères (environ 3.5e12 possibilités) et peut aller de quatre à trente-deux ; quatre est le plancher strict car les espaces de trois caractères sont trop petits pour les raccourcisseurs ouverts sur Internet et invitent à l’énumération par force brute de votre espace de chemins.
Où un générateur de slug d’URL courte avec graine apporte de la valeur
Les backends de raccourcisseur auto-hébergés utilisent cette capacité pour précalculer des codes dans des workers avant un insert transactionnel, en gardant une logique d’allocation identique dans chaque région sans partager une séquence aléatoire centrale. Les équipes d’opérations marketing génèrent des codes de campagne stables hors ligne à partir d’une URL d’atterrissage connue et d’une graine de campagne, afin que la revue créative, l’art QR et la bascule en production partagent une seule chaîne.
Les produits SaaS multi-locataires passent l’id du locataire comme seed pour que le client A et le client B ne reçoivent jamais le même chemin public pour des destinations identiques, ce qui simplifie la revue d’abus et les récits de résidence des données. Préférez des longueurs plus grandes lorsque votre espace de noms est public et durable ; n’utilisez le minimum quatre que pour des systèmes fermés avec gestion agressive des collisions.
Souvenez-vous que ce point de terminaison ne crée pas de redirections, ne mesure pas les clics et ne réserve pas de DNS—il ne fait que frapper le segment de chemin opaque que votre raccourcisseur stockera.
Cas d’usage
Allocation dans un raccourcisseur auto-hébergé
Précalculez un code de chemin base62 déterministe à partir de l’URL longue et d’une graine de service avant d’écrire la ligne de redirection dans votre propre base de données.
Codes de campagne multi-locataires
Mélangez une graine de locataire ou de campagne avec la même URL d’atterrissage pour que chaque client obtienne un slug public distinct sans aléatoire central.
Questions fréquentes
Pourquoi length inférieur à 4 est-il rejeté ?
Les codes de moins de quatre caractères base62 sont trop petits pour les espaces de noms publics de raccourcisseur et faciles à énumérer.
Cela crée-t-il un lien court en direct ?
Non. Cela calcule seulement une chaîne de slug déterministe. Vous stockez le mappage et servez les redirections sur votre propre domaine ou service de raccourcissement.
Quel alphabet le slug utilise-t-il ?
Base62 standard : chiffres 0-9, majuscules A-Z et minuscules a-z. La réponse fixe alphabet à base62 et length au nombre de caractères résolu.
Deux URL différentes peuvent-elles recevoir le même code ?
Oui, surtout avec des longueurs courtes. Les mêmes données donnent toujours le même code, mais deux adresses différentes peuvent tomber sur le même. Vérifiez l'unicité à l'enregistrement et choisissez plus de caractères pour des liens publics et durables.
À quoi sert une graine différente pour chaque client ?
À ce que deux clients qui raccourcissent la même adresse obtiennent des codes différents. Un espace de liens public ne révèle alors pas que deux organisations visent la même destination. La graine peut être l'identifiant du client ou le nom d'une campagne.
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/web/url-shortener-slug-generate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com/docs/guide","seed":"tenant-acme-v1"}'const res = await fetch("https://api.kit.forhosting.com/web/url-shortener-slug-generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://example.com/docs/guide",
"seed": "tenant-acme-v1"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/url-shortener-slug-generate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://example.com/docs/guide",
"seed": "tenant-acme-v1"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/url-shortener-slug-generate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://example.com/docs/guide","seed":"tenant-acme-v1"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://example.com/docs/guide","seed":"tenant-acme-v1"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/url-shortener-slug-generate", 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
{
"url": "https://example.com/docs/guide",
"seed": "tenant-acme-v1"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.url_shortener_slug_generate",
"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
timeout_sec | 30 |
max_crawl_pages | 25 |
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
Rien n’est récupéré sur le réseau et rien n’est stocké : vous obtenez la chaîne du slug et un préfixe short_path prêt, puis vous le liez dans votre propre magasin. Les longueurs inférieures à quatre échouent avec invalid_input car des codes aussi courts sont peu sûrs pour les espaces de noms publics de raccourcisseur à toute échelle significative.
Comment le slug base62 du raccourcisseur à graine est construit
La réponse renvoie url, seed et length, le slug, alphabet égal à base62, et short_path comme commodité préfixée d’une barre pour coller dans des modèles—sans prétendre que ce chemin est actif sur un domaine quelconque.
Contrat d’entrée, forme de la réponse et règles de rejet
Associez le slug à votre propre contrôle d’unicité à l’écriture : la fonction est déterministe pour un triple d’entrées, mais deux URL différentes peuvent encore colliser en codes courts—votre magasin doit traiter les courses d’insertion comme source de vérité. Envoyez un objet JSON avec deux chaînes obligatoires et un entier optionnel. Le champ url (alias target, link, href, long_url) est la destination longue que vous comptez lier ensuite ; elle n’est pas récupérée, donc localhost, chemins profonds et chaînes de requête sont acceptés comme texte opaque après trim, jusqu’à quatre mille quatre-vingt-seize caractères. Le champ seed (alias key, salt, namespace, secret) est une chaîne non vide qui espace le hachage—utilisez un secret par locataire ou un id de gamme produit pour rendre les collisions entre locataires improbables. Le champ length (alias len, size, slug_length) vaut sept s’il est omis ; il doit être un entier de quatre à trente-deux inclus. Les valeurs inférieures à quatre lèvent invalid_input avec un message indiquant le minimum de slug de raccourcisseur ; les valeurs au-dessus de trente-deux et les non-entiers sont également rejetés et ne sont pas facturés. En cas de succès le corps inclut les chaînes url et seed normalisées, la longueur résolue, le slug, alphabet fixé à base62, short_path égal à barre plus slug, et une courte note rappelant aux clients qu’il s’agit d’un code déterministe, pas d’une redirection en direct. url ou seed vides, objets non chaînes pour ces champs et clés obligatoires manquantes échouent clairement afin que les interfaces de formulaire mettent le champ en évidence.
Où un générateur de slug d’URL courte avec graine apporte de la valeur
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 ; une validation échouée ne consomme pas le solde.
Cas d'intégration
Fixtures stables QR et impression
Verrouillez url, seed et length dans les outils de conception afin que emballage, modèles SMS et goldens CI s’accordent toujours sur la chaîne de chemin court.
Questions techniques
Comment générer un slug d’URL courte à partir d’une URL et d’une graine ?
Envoyez des chaînes non vides url et seed, et optionnellement length (défaut 7, min 4, max 32). L’API renvoie un slug base62 déterministe et short_path tel que /Ab3x9kQ.
Combien coûte le générateur de slug d’URL courte avec graine ?
L’outil 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.