Pour auditer un site WordPress, il est souvent utile de repérer les articles très courts. Non pas parce qu’un article de moins de 300 mots serait automatiquement mauvais, mais parce qu’il mérite une vérification éditoriale.
Un contenu court peut être parfaitement légitime : une brève, une vidéo, une note technique, une citation, une commande utile. Mais il peut aussi signaler un vieil article trop mince, une page oubliée, un contenu cannibalisé, ou un billet qui ne répond plus vraiment à l’intention de recherche.
Voici donc plusieurs méthodes pour trouver les articles WordPress de moins de 300 mots : en SQL, avec WP-CLI, et avec un export CSV exploitable pour une vraie refonte éditoriale.
Méthode rapide : trouver les articles courts avec SQL
La méthode la plus directe consiste à interroger la table wp_posts. WordPress stocke le contenu principal des articles dans la colonne post_content.
Voici une requête simple pour trouver les articles publiés qui contiennent moins de 300 mots environ :
SELECT
ID,
post_title,
post_name,
post_date,
(
LENGTH( TRIM( post_content ) ) - LENGTH( REPLACE( TRIM( post_content ), ' ', '' ) ) + 1
) AS estimated_word_count
FROM wp_posts
WHERE post_type = 'post'
AND post_status = 'publish'
AND TRIM( post_content ) != ''
AND (
LENGTH( TRIM( post_content ) ) - LENGTH( REPLACE( TRIM( post_content ), ' ', '' ) ) + 1
) < 300
ORDER BY estimated_word_count ASC;Langage du code : PHP (php)Cette requête donne une estimation rapide. Elle compte les séparateurs d’espaces, ce qui suffit pour un premier repérage. En revanche, elle ne nettoie pas vraiment le HTML, les commentaires Gutenberg, les shortcodes ou les espaces multiples.
Version SQL avec l’URL de l’article
Pour rendre l’audit plus pratique, vous pouvez générer directement l’URL de chaque article. Remplacez le domaine par celui de votre site :
SELECT
ID,
post_title,
CONCAT( 'https://www.example.com/', post_name, '/' ) AS url,
post_date,
(
LENGTH( TRIM( post_content ) ) - LENGTH( REPLACE( TRIM( post_content ), ' ', '' ) ) + 1
) AS estimated_word_count
FROM wp_posts
WHERE post_type = 'post'
AND post_status = 'publish'
AND TRIM( post_content ) != ''
AND (
LENGTH( TRIM( post_content ) ) - LENGTH( REPLACE( TRIM( post_content ), ' ', '' ) ) + 1
) < 300
ORDER BY estimated_word_count ASC;Langage du code : PHP (php)Cette version fonctionne si vos permaliens utilisent simplement le slug de l’article. Si votre structure inclut la date, la catégorie ou un préfixe personnalisé, préférez WP-CLI. Il utilisera les permaliens réels du site.
Méthode plus fiable : utiliser WP-CLI
La méthode SQL est rapide, mais elle reste approximative. Pour un audit plus fiable, utilisez WordPress lui-même pour récupérer le contenu, nettoyer les blocs et générer les vraies URLs.
Voici une commande WP-CLI qui liste les articles publiés de moins de 300 mots :
wp eval '
$posts = get_posts(
array(
"post_type" => "post",
"post_status" => "publish",
"posts_per_page" => -1,
"fields" => "ids",
)
);
foreach ( $posts as $post_id ) {
$content = get_post_field( "post_content", $post_id );
$content = do_blocks( $content );
$content = wp_strip_all_tags( strip_shortcodes( $content ) );
$words = preg_split( "/[\s\p{P}]+/u", trim( $content ), -1, PREG_SPLIT_NO_EMPTY );
$count = is_array( $words ) ? count( $words ) : 0;
if ( $count < 300 ) {
printf(
"%d\t%d\t%s\t%s\n",
$post_id,
$count,
get_the_title( $post_id ),
get_permalink( $post_id )
);
}
}
'Langage du code : PHP (php)Cette commande est plus pertinente, car elle passe par WordPress. Elle peut donc obtenir les permaliens corrects, retirer les balises HTML, traiter les blocs Gutenberg, supprimer les shortcodes, puis compter les mots de manière plus réaliste.
Le résultat affiche quatre colonnes :
- l’ID de l’article ;
- le nombre de mots estimé ;
- le titre ;
- l’URL.
Exporter les articles courts en CSV
Pour travailler proprement dans un tableur, exportez les résultats en CSV :
wp eval '
$posts = get_posts(
array(
"post_type" => "post",
"post_status" => "publish",
"posts_per_page" => -1,
"fields" => "ids",
)
);
$handle = fopen( "php://output", "w" );
fputcsv( $handle, array( "ID", "word_count", "post_date", "title", "url" ) );
foreach ( $posts as $post_id ) {
$content = get_post_field( "post_content", $post_id );
$content = do_blocks( $content );
$content = wp_strip_all_tags( strip_shortcodes( $content ) );
$words = preg_split( "/[\s\p{P}]+/u", trim( $content ), -1, PREG_SPLIT_NO_EMPTY );
$count = is_array( $words ) ? count( $words ) : 0;
if ( $count < 300 ) {
fputcsv(
$handle,
array(
$post_id,
$count,
get_post_field( "post_date", $post_id ),
get_the_title( $post_id ),
get_permalink( $post_id ),
)
);
}
}
fclose( $handle );
' > articles-moins-300-mots.csvLangage du code : PHP (php)Vous pouvez ensuite ouvrir articles-moins-300-mots.csv dans LibreOffice, Excel, Google Sheets, Numbers ou votre outil d’audit favori.
Pour vérifier rapidement le fichier :
head articles-moins-300-mots.csvLangage du code : CSS (css)Et pour compter le nombre d’articles concernés :
wc -l articles-moins-300-mots.csvLangage du code : CSS (css)Le nombre retourné inclut la ligne d’en-tête. Donc, si wc -l retourne 51, vous avez 50 articles à examiner. Oui, les CSV ont aussi leur petit sens de l’humour.
Créer un vrai script WP-CLI réutilisable
Si vous faites souvent des audits éditoriaux, créez un script dédié. Par exemple : audit-short-posts.php.
<?php
/**
* Audit WordPress posts with fewer than a given number of words.
*
* Usage:
* wp eval-file audit-short-posts.php -- 300 > articles-courts.csv
*/
declare(strict_types=1);
$threshold = isset( $args[0] ) ? absint( $args[0] ) : 300;
$posts = get_posts(
array(
'post_type' => 'post',
'post_status' => 'publish',
'posts_per_page' => -1,
'fields' => 'ids',
)
);
$handle = fopen( 'php://output', 'w' );
if ( false === $handle ) {
WP_CLI::error( 'Unable to open output stream.' );
}
fputcsv( $handle, array( 'ID', 'word_count', 'post_date', 'title', 'url' ) );
/**
* Count words in post content after WordPress-aware cleanup.
*
* @param string $content Raw post content.
*
* @return int Word count.
*/
function skyminds_count_words_in_content( string $content ): int {
$content = do_blocks( $content );
$content = strip_shortcodes( $content );
$content = wp_strip_all_tags( $content );
$content = html_entity_decode( $content, ENT_QUOTES | ENT_HTML5, get_bloginfo( 'charset' ) );
$words = preg_split( '/[\s\p{P}]+/u', trim( $content ), -1, PREG_SPLIT_NO_EMPTY );
return is_array( $words ) ? count( $words ) : 0;
}
foreach ( $posts as $post_id ) {
$content = (string) get_post_field( 'post_content', $post_id );
$word_count = skyminds_count_words_in_content( $content );
if ( $word_count >= $threshold ) {
continue;
}
fputcsv(
$handle,
array(
$post_id,
$word_count,
get_post_field( 'post_date', $post_id ),
get_the_title( $post_id ),
get_permalink( $post_id ),
)
);
}
fclose( $handle );Langage du code : HTML, XML (xml)Lancez ensuite le script avec WP-CLI :
wp eval-file audit-short-posts.php -- 300 > articles-moins-300-mots.csvLangage du code : CSS (css)Pour chercher les articles de moins de 500 mots :
wp eval-file audit-short-posts.php -- 500 > articles-moins-500-mots.csvLangage du code : CSS (css)Ce script est plus propre qu’une grosse commande inline. Il est versionnable, réutilisable, et beaucoup moins pénible à relire six mois plus tard.
Limiter l’audit à certaines catégories
Sur un gros site, vous pouvez vouloir auditer uniquement une catégorie. Dans ce cas, ajoutez un filtre category ou category_name dans la requête.
Exemple avec un ID de catégorie :
$posts = get_posts(
array(
'post_type' => 'post',
'post_status' => 'publish',
'posts_per_page' => -1,
'fields' => 'ids',
'category' => 2,
)
);Langage du code : PHP (php)Exemple avec un slug de catégorie :
$posts = get_posts(
array(
'post_type' => 'post',
'post_status' => 'publish',
'posts_per_page' => -1,
'fields' => 'ids',
'category_name' => 'wordpress',
)
);Langage du code : PHP (php)Pour trouver les IDs de catégories avec WP-CLI :
wp term list category --fields=term_id,name,slug,countLangage du code : PHP (php)Pour d’autres exports éditoriaux en ligne de commande, vous pouvez aussi consulter le guide sur la liste des articles publiés avec WP-CLI. Il complète bien cet audit quand vous voulez exporter des URLs par lots ou par catégorie.
Auditer les pages en plus des articles
Pour auditer les pages WordPress, remplacez simplement post par page :
'post_type' => 'page',Langage du code : PHP (php)Pour auditer articles et pages en même temps :
'post_type' => array( 'post', 'page' ),Langage du code : PHP (php)Dans l’export CSV, ajoutez alors le type de contenu pour mieux trier :
get_post_type( $post_id )Langage du code : PHP (php)Pourquoi 300 mots n’est pas une règle SEO absolue
Un article court n’est pas automatiquement un mauvais article. Google ne classe pas les pages uniquement selon un compteur de mots. Une page courte peut répondre parfaitement à une intention simple.
En revanche, un article très court mérite un examen. Posez-vous les bonnes questions :
- répond-il clairement à une intention de recherche ?
- a-t-il encore du trafic organique ?
- reçoit-il des liens internes ou externes ?
- cannibalise-t-il un article plus complet ?
- contient-il une vidéo, un code ou une ressource qui justifie sa brièveté ?
- peut-il être fusionné avec un article plus récent ?
- doit-il être refondu, redirigé ou désindexé ?
Le bon objectif n’est pas d’allonger tous les articles pour atteindre un chiffre magique. Le bon objectif est d’améliorer l’utilité réelle de chaque contenu. Les mots ne sont pas une stratégie. Ils sont juste les briques.
Que faire des articles de moins de 300 mots ?
Une fois la liste exportée, classez les articles en quatre groupes.
1. Les articles à conserver tels quels
Certains contenus courts sont utiles. Par exemple : une commande Linux, une correction rapide, une vidéo, une citation, une astuce très ciblée. Si la page répond bien au besoin, ne l’allongez pas artificiellement.
2. Les articles à enrichir
Ce sont les meilleurs candidats pour une refonte. Ajoutez un contexte clair, une procédure complète, des exemples, des captures, une FAQ, des sources, et des liens internes pertinents.
Pour les articles techniques WordPress, vous pouvez souvent ajouter une section diagnostic, une commande WP-CLI, une checklist, puis une version moderne du code. C’est exactement le type de refonte qui transforme une vieille note en guide durable.
3. Les articles à fusionner
Si plusieurs petits articles traitent du même sujet, fusionnez-les dans un guide plus solide. Ensuite, redirigez les anciennes URLs vers la nouvelle page avec une redirection 301.
C’est souvent le meilleur choix contre la cannibalisation SEO. Un bon article complet vaut mieux que cinq mini-articles qui se marchent dessus avec enthousiasme.
4. Les articles à supprimer ou désindexer
Si un contenu est obsolète, sans trafic, sans lien, sans utilité, et sans potentiel de refonte, vous pouvez envisager sa suppression. Dans ce cas, choisissez une stratégie propre : redirection 301 si une page équivalente existe, 410 si le contenu disparaît définitivement, ou noindex si vous voulez le garder pour les lecteurs sans le pousser dans l’index.
Pour les erreurs techniques liées aux suppressions ou contenus introuvables, le guide sur les images WordPress en erreur 403 montre une méthode de diagnostic utile : vérifier le symptôme, identifier la cause, puis corriger proprement au lieu de bricoler.
Prioriser avec Google Search Console
Le nombre de mots ne suffit pas pour prioriser. Croisez votre export avec Google Search Console :
- clics sur les 16 derniers mois ;
- impressions ;
- position moyenne ;
- requêtes associées ;
- pages qui perdent du trafic ;
- pages qui ont beaucoup d’impressions mais peu de clics.
Un article court avec beaucoup d’impressions et peu de clics mérite souvent une refonte du titre, de l’introduction, du contenu et de la meta description.
À l’inverse, un article court sans impression depuis deux ans n’est pas forcément prioritaire. Il faut parfois accepter qu’une page ait fait son temps. Paix à son slug.
Ajouter le nombre de mots en post meta
Si vous voulez auditer régulièrement vos contenus, vous pouvez stocker le nombre de mots en meta. Cela évite de recalculer tout le contenu à chaque fois.
Voici un exemple de script WP-CLI qui calcule le nombre de mots et l’enregistre dans _skyminds_word_count :
<?php
/**
* Store WordPress post word counts in post meta.
*
* Usage:
* wp eval-file store-word-counts.php
*/
declare(strict_types=1);
$posts = get_posts(
array(
'post_type' => 'post',
'post_status' => 'publish',
'posts_per_page' => -1,
'fields' => 'ids',
)
);
/**
* Count words in WordPress post content.
*
* @param string $content Raw post content.
*
* @return int Word count.
*/
function skyminds_get_clean_word_count( string $content ): int {
$content = do_blocks( $content );
$content = strip_shortcodes( $content );
$content = wp_strip_all_tags( $content );
$content = html_entity_decode( $content, ENT_QUOTES | ENT_HTML5, get_bloginfo( 'charset' ) );
$words = preg_split( '/[\s\p{P}]+/u', trim( $content ), -1, PREG_SPLIT_NO_EMPTY );
return is_array( $words ) ? count( $words ) : 0;
}
foreach ( $posts as $post_id ) {
$content = (string) get_post_field( 'post_content', $post_id );
$word_count = skyminds_get_clean_word_count( $content );
update_post_meta( $post_id, '_skyminds_word_count', $word_count );
WP_CLI::log(
sprintf(
'Post #%d: %d words',
$post_id,
$word_count
)
);
}
WP_CLI::success( 'Word counts stored successfully.' );Langage du code : HTML, XML (xml)Lancez-le ainsi :
wp eval-file store-word-counts.phpLangage du code : JavaScript (javascript)Ensuite, vous pouvez interroger les articles courts via la meta. Mais pour un audit ponctuel, l’export CSV suffit largement.
Checklist d’audit des contenus courts
- Exporter les articles de moins de 300 mots.
- Vérifier manuellement les faux positifs.
- Croiser avec Google Search Console.
- Identifier les articles utiles malgré leur brièveté.
- Repérer les contenus obsolètes.
- Repérer les articles qui cannibalisent un guide plus complet.
- Ajouter du maillage interne pertinent.
- Fusionner les contenus proches si nécessaire.
- Rediriger les anciennes URLs après fusion.
- Mettre à jour le sitemap après grosses suppressions ou fusions.
Si vous devez vérifier ensuite le sitemap du site, l’article sur The SEO Framework et les erreurs 404 de sitemap sous nginx complète bien ce travail. Après une refonte massive, le sitemap doit répondre correctement et refléter les contenus canoniques.
Commandes utiles à garder
Requête SQL rapide :
SELECT ID, post_title, post_date
FROM wp_posts
WHERE post_type = 'post'
AND post_status = 'publish'
AND (
LENGTH( TRIM( post_content ) ) - LENGTH( REPLACE( TRIM( post_content ), ' ', '' ) ) + 1
) < 300;Langage du code : JavaScript (javascript)Export WP-CLI des articles publiés :
wp post list --post_type=post --post_status=publish --fields=ID,post_title,post_date,url --format=csv > articles-publies.csvLangage du code : PHP (php)Liste des catégories :
wp term list category --fields=term_id,name,slug,countLangage du code : PHP (php)Audit avec un script dédié :
wp eval-file audit-short-posts.php -- 300 > articles-moins-300-mots.csvLangage du code : CSS (css)Conclusion
Pour trouver les articles WordPress de moins de 300 mots, une requête SQL suffit pour un premier audit rapide. Mais pour un résultat plus fiable, WP-CLI reste supérieur : il permet de nettoyer le contenu avec WordPress, de récupérer les vraies URLs, puis d’exporter un CSV exploitable.
Le plus important vient ensuite : ne supprimez pas mécaniquement tous les articles courts. Analysez leur utilité, leur trafic, leur intention, leur fraîcheur et leur rôle dans le maillage interne. Certains méritent une refonte. Certains doivent être fusionnés. Certains peuvent rester courts. Et quelques-uns peuvent prendre une retraite bien méritée.
