WordPress RSS feed URLs explained

WordPress RSS feed URLs are more extensive than the familiar /feed/ address. WordPress can generate feeds for recent posts, comments, individual post discussions, categories, tags, authors, search results, custom taxonomies and public custom post type archives.

The exact URL depends on:

• the type of content being requested;
• the site’s permalink configuration;
• the requested feed format;
• the registered taxonomy or post type;
• filters and custom rewrite rules added by plugins or themes.

With a typical pretty-permalink configuration, the main WordPress feed looks like:

https://example.com/feed/

But that is only the beginning.

A WordPress installation can also expose URLs resembling:

https://example.com/comments/feed/

https://example.com/category/security/feed/

https://example.com/tag/wordpress/feed/

https://example.com/author/jane/feed/

https://example.com/an-article/feed/

https://example.com/books/feed/

https://example.com/topic/development/feed/

https://example.com/search/security/feed/rss2/

This guide maps the main WordPress RSS feed URL patterns, explains how WordPress generates them, shows the Core functions you should use instead of hardcoding URLs and explains how feed URLs differ from the RSS discovery links WordPress inserts into normal HTML pages.

Quick reference: common WordPress feed URLs

Feed	Typical pretty URL
Main posts feed	/feed/
Atom posts feed	/feed/atom/
RDF feed	/feed/rdf/
RSS 0.92 feed	/feed/rss/
Site comments feed	/comments/feed/
Comments Atom feed	/comments/feed/atom/
Single post comments feed	/post-slug/feed/
Category feed	/category/category-slug/feed/
Tag feed	/tag/tag-slug/feed/
Author feed	/author/username/feed/
Custom taxonomy term feed	/taxonomy/term/feed/
Custom post type archive feed	/post-type-archive/feed/
Search results feed	/search/query/feed/rss2/

These examples assume conventional pretty permalinks and default-style rewrite structures.

Do not hardcode these patterns into production code when WordPress already provides a function that can generate the correct URL for the current installation.

What is a WordPress feed?

A feed is a machine-readable representation of site content intended for syndication.

Instead of returning a normal HTML webpage, a feed returns structured content that applications can process.

Typical consumers include:

• RSS readers;
• news aggregators;
• newsletter services;
• automation platforms;
• content syndication systems;
• monitoring tools;
• custom applications.

The official WordPress Feeds documentation describes the feed formats included with WordPress.

WordPress supports several feed formats

WordPress Core supports feed output including:

RSS 2.0
RSS 0.92
RDF / RSS 1.0
Atom

The default feed is normally:

RSS 2.0

WordPress’s default feed is configurable

Core provides:

get_default_feed()

The official get_default_feed() documentation confirms that WordPress defaults to:

rss2

unless the:

default_feed

filter changes it.

That matters when reading WordPress feed URLs

Because RSS2 is normally the default, WordPress can use the shorter:

/feed/

instead of requiring:

/feed/rss2/

for the canonical feed URL generated by Core.

The main WordPress posts feed

The most familiar WordPress feed is:

https://example.com/feed/

This normally represents the site’s recent posts using the default feed format.

Because WordPress normally uses RSS2 as the default:

/feed/
→ RSS 2.0

Generate the main feed URL with get_feed_link()

WordPress provides:

get_feed_link()

The official get_feed_link() documentation describes it as the function for retrieving a feed permalink.

Use:

$feed_url =
    get_feed_link();

echo esc_url(
    $feed_url
);

With standard pretty permalinks, this will typically produce:

https://example.com/feed/

Do not concatenate /feed/ manually

This is tempting:

$feed_url =
    home_url( '/feed/' );

but it assumes the site’s current rewrite configuration.

Prefer:

get_feed_link()

because WordPress knows whether the installation is using:

• pretty permalinks;
• query-string feed URLs;
• a filtered default feed;
• custom feed URL filtering.

RSS 2.0 feed URL

You can request RSS2 explicitly:

get_feed_link(
    'rss2'
);

Because RSS2 is normally the default feed, WordPress’s generated pretty URL remains:

https://example.com/feed/

Atom feed URL

The standard Atom feed can be retrieved with:

get_feed_link(
    'atom'
);

With pretty permalinks, the typical result is:

https://example.com/feed/atom/

WordPress also exposes the Atom feed through:

get_bloginfo(
    'atom_url'
);

The official get_bloginfo() documentation identifies atom_url as the site’s Atom feed URL.

RSS 0.92 feed URL

WordPress still includes support for the older RSS 0.92 feed format.

The traditional pretty URL is:

https://example.com/feed/rss/

It can also be obtained through:

get_bloginfo(
    'rss_url'
);

RDF / RSS 1.0 feed URL

The RDF feed typically uses:

https://example.com/feed/rdf/

WordPress exposes the generated URL through:

get_bloginfo(
    'rdf_url'
);

Main feed formats overview

Format	Typical pretty URL	WordPress value
RSS 2.0	/feed/	rss2
Atom	/feed/atom/	atom
RSS 0.92	/feed/rss/	rss
RDF / RSS 1.0	/feed/rdf/	rdf

What happens without pretty permalinks?

WordPress does not require:

/feed/

to provide RSS.

When a permalink structure is unavailable, Core can generate query-string URLs instead.

For example:

https://example.com/?feed=rss2

for RSS2.

Other query-string examples

https://example.com/?feed=atom

https://example.com/?feed=rdf

https://example.com/?feed=rss

This is one reason code should use WordPress URL-generation functions instead of assuming:

home_url() . '/feed/'

Pretty URL and query URL can represent the same feed

Conceptually:

/feed/

and

/?feed=rss2

refer to the same type of WordPress feed request under different permalink configurations.

The site-wide comments feed

WordPress can also provide a feed containing recent comments across the website.

The normal pretty URL is:

https://example.com/comments/feed/

This is not the same as the main posts feed.

Main posts feed vs comments feed

/feed/
→ recent posts

/comments/feed/
→ recent comments

Generate the comments RSS2 feed programmatically

WordPress can retrieve this through:

get_feed_link(
    'comments_rss2'
);

You can also use:

get_bloginfo(
    'comments_rss2_url'
);

Comments Atom feed

An Atom representation can also be generated.

For example:

get_feed_link(
    'comments_atom'
);

With pretty permalinks, this typically produces:

https://example.com/comments/feed/atom/

Site-wide comments feed vs individual post comments feed

These are distinct.

/comments/feed/
→ comments from across the site

/post-slug/feed/
→ comments for one post

Individual post comment feeds

This is one of the WordPress feed URL patterns that causes the most confusion.

Suppose a post has the permalink:

https://example.com/how-to-secure-wordpress/

Its comments feed can be:

https://example.com/how-to-secure-wordpress/feed/

The feed below a singular post is a comments feed

It is not another feed containing only that post.

Conceptually:

/article/
→ HTML article

/article/feed/
→ comments associated
   with that article

Use get_post_comments_feed_link()

WordPress provides:

get_post_comments_feed_link()

The official get_post_comments_feed_link() documentation generates the comments-feed permalink for a specific post.

For example:

$comments_feed =
    get_post_comments_feed_link(
        123
    );

echo esc_url(
    $comments_feed
);

Request an Atom comments feed for one post

$comments_atom =
    get_post_comments_feed_link(
        123,
        'atom'
    );

For a normal pretty permalink, the pattern becomes approximately:

/post-slug/feed/atom/

Without pretty permalinks, post comment feeds use query arguments

For a normal post, Core can generate something resembling:

https://example.com/?feed=rss2&p=123

For a page, the equivalent can use:

page_id

instead.

This logic is one more reason to use:

get_post_comments_feed_link()

instead of manually constructing the address.

Category feed URLs

Every ordinary WordPress category can have its own feed.

Suppose the category archive is:

https://example.com/category/security/

The corresponding default feed is normally:

https://example.com/category/security/feed/

Category feeds contain posts in that category

This provides a narrower syndication stream than the global posts feed.

/feed/
→ recent posts across site

/category/security/feed/
→ recent posts in Security

Generate category feed URLs with get_category_feed_link()

WordPress provides:

get_category_feed_link()

The official get_category_feed_link() documentation retrieves the feed URL for posts assigned to a category.

For example:

$feed_url =
    get_category_feed_link(
        12
    );

Request another format

$atom_url =
    get_category_feed_link(
        12,
        'atom'
    );

The resulting pretty URL typically follows:

/category/security/feed/atom/

Category feeds without pretty permalinks

The underlying Core implementation can generate URLs using:

?feed=rss2&cat=12

where:

12
→ category ID

Tag feed URLs

WordPress tags have their own feed streams too.

If the tag archive is:

https://example.com/tag/wordpress/

the normal default feed is:

https://example.com/tag/wordpress/feed/

Use get_tag_feed_link()

WordPress provides:

get_tag_feed_link()

The official get_tag_feed_link() documentation retrieves a feed permalink for a specific post tag.

$feed_url =
    get_tag_feed_link(
        25
    );

Tag feeds without pretty permalinks

Core can generate a query-string URL resembling:

?feed=rss2&tag=wordpress

Notice the difference from categories:

Category
→ cat=term_ID

Tag
→ tag=term_slug

Categories and tags are both term feeds internally

The specialized functions ultimately rely on:

get_term_feed_link()

This is important because WordPress is not limited to the built-in category and tag taxonomies.

Custom taxonomy feed URLs

Suppose a site registers a custom taxonomy:

topic

with a term:

development

If its archive URL is:

https://example.com/topic/development/

the term feed can typically be:

https://example.com/topic/development/feed/

Use get_term_feed_link()

WordPress provides:

get_term_feed_link()

The official get_term_feed_link() documentation supports categories, tags and custom taxonomies.

For example:

$feed_url =
    get_term_feed_link(
        42,
        'topic'
    );

Request an Atom custom taxonomy feed

$feed_url =
    get_term_feed_link(
        42,
        'topic',
        'atom'
    );

With pretty permalinks, this can produce:

/topic/development/feed/atom/

Custom taxonomy query-string feeds

When pretty permalinks are unavailable, WordPress uses the taxonomy’s query variable.

Conceptually:

?feed=rss2&topic=development

assuming:

topic

is the taxonomy’s registered query variable.

Do not assume the taxonomy rewrite base equals the taxonomy name

A taxonomy registered as:

book_genre

could use a rewrite slug such as:

genre

producing:

/genre/science-fiction/feed/

rather than:

/book_genre/science-fiction/feed/

This is exactly why:

get_term_feed_link()

is safer than constructing URLs manually.

Author feed URLs

WordPress can expose all posts written by one author as a feed.

If the author archive is:

https://example.com/author/jane/

the default author feed is typically:

https://example.com/author/jane/feed/

Use get_author_feed_link()

WordPress provides:

get_author_feed_link()

The official get_author_feed_link() documentation retrieves all posts for a specified author as a feed.

$feed_url =
    get_author_feed_link(
        7
    );

Request another author feed format

$atom_url =
    get_author_feed_link(
        7,
        'atom'
    );

The pretty URL normally follows:

/author/jane/feed/atom/

Author feeds without pretty permalinks

WordPress can produce:

?feed=rss2&author=7

where:

7
→ WordPress user ID

Author feeds can expose publishing relationships

An author feed can make it easy for an application to monitor content associated with a particular public author archive.

This is normal syndication behavior.

If the site intentionally does not use public author archives or feeds, review those features together rather than assuming removing an author link from a theme removes the feed endpoint.

Search results feed URLs

WordPress can also expose a feed for search results.

For example, searching for:

security

might produce a search archive similar to:

https://example.com/search/security/

The corresponding RSS2 feed generated by current Core follows:

https://example.com/search/security/feed/rss2/

Search feeds are slightly different from many archive feeds

For categories and authors, the default format can often be represented simply by:

/feed/

at the end of the archive URL.

Current get_search_feed_link() explicitly appends the feed type to a pretty search feed URL:

feed/rss2/

for the default RSS2 format.

Use get_search_feed_link()

WordPress provides:

get_search_feed_link()

The official get_search_feed_link() documentation generates the feed permalink for a search query.

$feed_url =
    get_search_feed_link(
        'security'
    );

Generate an Atom search feed

$atom_url =
    get_search_feed_link(
        'security',
        'atom'
    );

The pretty URL becomes approximately:

/search/security/feed/atom/

Search feeds without pretty permalinks

WordPress begins with the normal search query:

?s=security

and adds the feed parameter.

The resulting URL is conceptually:

?s=security&feed=rss2

Search comments feeds also exist in Core

WordPress includes:

get_search_comments_feed_link()

for generating a comments-oriented feed corresponding to search results.

It is much less commonly used than the normal search-posts feed, but it demonstrates how broad WordPress’s feed infrastructure actually is.

Custom post type archive feeds

Public custom post types can have archive feeds when their configuration supports them.

Suppose a custom post type:

book

has an archive at:

https://example.com/books/

Its default feed can be:

https://example.com/books/feed/

Use get_post_type_archive_feed_link()

WordPress provides:

get_post_type_archive_feed_link()

The official get_post_type_archive_feed_link() documentation returns the feed URL for a post type archive.

For example:

$feed_url =
    get_post_type_archive_feed_link(
        'book'
    );

The post type must have an archive

If the post type does not expose an archive, the Core function can return:

false

Pretty feed URLs also depend on the post type rewrite configuration

Current Core checks whether the post type’s rewrite settings allow feeds before constructing the pretty:

/archive/feed/

form.

Request another post type feed format

$atom_url =
    get_post_type_archive_feed_link(
        'book',
        'atom'
    );

This can produce:

/books/feed/atom/

Do not assume every custom post type has a feed

A custom post type can be registered with:

• no public archive;
• custom rewrite settings;
• feeds disabled in the rewrite configuration;
• plugin-specific routing.

Always ask WordPress for the URL instead of assuming:

/post-type/feed/

must exist.

Do Pages have their own normal content feeds?

Pages are not normally included in the main chronological WordPress posts feed.

The official WordPress documentation distinguishes Pages from Posts and notes that Pages do not normally appear in the site’s standard RSS or Atom content feed.

Pages can still have comment feeds

A Page is still a singular WordPress object.

If discussion is available for that Page, its comments can have a feed generated through:

get_post_comments_feed_link()

So:

Page content feed
→ not the normal model

Page comments feed
→ possible

Feed URLs and permalink structures

WordPress feeds are built on the rewrite system.

This means two sites with identical content can expose different-looking feed addresses.

Pretty permalinks

https://example.com/category/security/feed/

Plain permalinks

https://example.com/?feed=rss2&cat=12

Both can represent the same logical resource.

The URL is not the feed identity

The useful abstraction is:

Category Security
+
RSS2 representation

WordPress determines how that resource should be expressed as a URL for the current configuration.

Use Core functions as the source of truth

A robust plugin should prefer:

get_feed_link()
get_post_comments_feed_link()
get_category_feed_link()
get_tag_feed_link()
get_term_feed_link()
get_author_feed_link()
get_search_feed_link()
get_post_type_archive_feed_link()

over manually concatenating:

'/feed/'

onto URLs.

Why hardcoded feed URLs can break

Assume a plugin does this:

$feed_url =
    home_url(
        '/category/news/feed/'
    );

Potential problems include:

• the category base has been changed;
• the category slug changed;
• pretty permalinks are disabled;
• the feed format changed;
• a filter modifies the generated URL;
• the taxonomy is not actually a category.

Better approach

$feed_url =
    get_category_feed_link(
        $category_id
    );

WordPress feed URLs can be filtered

Core exposes several filters for generated feed URLs.

Examples include:

feed_link
category_feed_link
tag_feed_link
taxonomy_feed_link
author_feed_link
search_feed_link
post_comments_feed_link
post_type_archive_feed_link

That means a plugin can deliberately change the URLs WordPress produces.

Another reason not to hardcode URLs

A generated WordPress URL is not necessarily determined only by permalink settings.

Plugins can alter it through filters too.

Custom feed types with add_feed()

WordPress is not limited to its built-in feed names.

Developers can register custom feeds through:

add_feed()

The official add_feed() documentation allows a custom feed name and rendering callback to be registered.

Example custom feed

function project_register_feed() {

    add_feed(
        'partners',
        'project_render_partner_feed'
    );
}

add_action(
    'init',
    'project_register_feed'
);

function project_render_partner_feed() {

    header(
        'Content-Type: application/rss+xml; charset=UTF-8'
    );

    // Render the custom feed.
}

This can create a feed type such as:

/feed/partners/

depending on the rewrite configuration.

Custom feeds require rewrite rules to be refreshed

The official add_feed() documentation notes that rewrite rules need to be refreshed when a new feed is introduced.

Do not call:

flush_rewrite_rules()

on every page request.

Refresh rewrite rules only at an appropriate lifecycle event such as plugin activation or a deliberate configuration change.

Plugin-defined feeds complicate RSS audits

If you are trying to identify every feed on a WordPress site, reviewing only:

rss
rss2
rdf
atom

may not be sufficient.

Plugins can register:

• export feeds;
• partner feeds;
• commerce feeds;
• special syndication formats;
• custom application feeds.

Do not block URLs merely because they contain /feed/

A custom feed might be critical to a real integration.

Audit what created the route before disabling it.

How WordPress recognizes a feed request

WordPress query processing can identify the request as a feed query.

Core then eventually uses:

do_feed()

to dispatch the request to the appropriate feed handler.

The official do_feed() documentation describes this dispatch process.

Feed handlers include

do_feed_rss
do_feed_rss2
do_feed_rdf
do_feed_atom

These handlers load the corresponding feed template.

The URL and the rendering format are related but separate

A request such as:

/feed/atom/

first needs to be recognized as:

feed request
+
feed type = atom

before WordPress renders the Atom output.

RSS2 feeds can represent several different queries

The URL:

/feed/

does not mean:

RSS2 always contains every post.

The query context matters.

For example:

/feed/
→ main posts query

/category/news/feed/
→ category query

/author/jane/feed/
→ author query

/books/feed/
→ custom post type archive query

The feed format may be the same while the underlying WordPress query is different.

Think of feed URLs as query + representation

A useful model is:

WordPress query
+
feed format
=
feed resource

For example:

Category = Security
+
Format = RSS2
=
Security category RSS feed

The same archive can have multiple feed formats

For example:

/category/security/feed/
→ default RSS2 feed

/category/security/feed/atom/
→ Atom representation

WordPress feed URL functions accept a format argument

This pattern is shared by several Core functions:

get_category_feed_link(
    $category_id,
    'atom'
);

get_tag_feed_link(
    $tag_id,
    'atom'
);

get_author_feed_link(
    $author_id,
    'atom'
);

get_term_feed_link(
    $term_id,
    'topic',
    'atom'
);

Use the default format unless you need a specific one

An empty feed-format argument lets WordPress use:

get_default_feed()

This is usually preferable to forcing RSS2 unnecessarily.

RSS feed URLs vs RSS discovery links

This distinction is essential.

A feed URL is an actual resource:

https://example.com/feed/

A feed discovery link is HTML metadata:

<link
    rel="alternate"
    type="application/rss+xml"
    href="https://example.com/feed/"
/>

Removing the discovery link does not remove the URL

If the HTML tag disappears:

/feed/
→ can still work

This is explained in depth in Disable RSS Feeds vs. Remove Feed Links.

How WordPress advertises feed URLs

General and contextual RSS discovery is generated primarily through:

feed_links()
feed_links_extra()

The first handles general feeds.

The second can advertise contextual feeds for the current query.

See How WordPress Advertises RSS Feeds by Default for the complete discovery system.

A page can advertise several feeds

A single post page might conceptually expose discovery for:

site posts feed
site comments feed
post-specific comments feed

while a category archive could advertise:

site posts feed
site comments feed
category feed

Do not determine available feeds only by inspecting the homepage

Contextual feeds appear according to the current query.

Inspect:

• single posts;
• category archives;
• tag archives;
• author archives;
• search results;
• custom taxonomy archives;
• custom post type archives.

Finding feed URLs from HTML source

Open the page source and search for:

application/rss+xml

You may find markup similar to:

<link
    rel="alternate"
    type="application/rss+xml"
    title="Example Site Feed"
    href="https://example.com/feed/"
/>

But HTML discovery is not a complete feed inventory

A feed can exist without being advertised.

Plugins may also create feed endpoints without inserting discovery tags automatically.

Use WordPress APIs when auditing feeds

When building diagnostic code, retrieve URLs directly from Core.

For example:

$feeds = array(
    'main' =>
        get_feed_link(),

    'atom' =>
        get_feed_link(
            'atom'
        ),

    'comments' =>
        get_feed_link(
            'comments_rss2'
        ),
);

Retrieve a category feed dynamically

$category =
    get_category_by_slug(
        'security'
    );

if ( $category ) {

    $feed =
        get_category_feed_link(
            $category->term_id
        );
}

Retrieve an author feed dynamically

$user =
    get_user_by(
        'slug',
        'jane'
    );

if ( $user ) {

    $feed =
        get_author_feed_link(
            $user->ID
        );
}

Retrieve a custom post type feed safely

$feed =
    get_post_type_archive_feed_link(
        'book'
    );

if ( false !== $feed ) {

    echo esc_url(
        $feed
    );
}

Always handle false where Core can return it

Functions such as:

get_post_type_archive_feed_link()
get_term_feed_link()

can fail when the requested object or archive does not exist.

Do not assume every call returns a valid URL.

Escaping feed URLs

When outputting a generated URL into HTML, use:

esc_url()

For example:

<a
    href="<?php
        echo esc_url(
            get_feed_link()
        );
    ?>"
>
    RSS Feed
</a>

WordPress can also output feed links directly

Core provides template functions such as:

the_feed_link()
post_comments_feed_link()

when direct HTML output is appropriate.

For plugin logic where you need the URL itself, the corresponding get_* functions are usually easier to work with.

What content appears inside the feed?

The URL determines which WordPress query is represented.

The feed configuration determines how much post content appears.

Under:

Settings
→ Reading

WordPress can configure syndication behavior including:

• the number of recent feed items;
• whether feeds contain full text or excerpts.

Changing excerpt mode does not change the feed URL

For example:

/feed/

can remain exactly the same while the content changes from:

full article

to:

excerpt

Feed URL and feed content are separate configuration layers

URL
→ which resource

feed query
→ which posts/comments

format
→ RSS2 / Atom / RDF

Reading Settings
→ amount of content

WordPress feeds and canonical HTML pages

A feed is an alternative representation of content.

It does not replace the ordinary HTML archive or post.

For example:

/category/security/
→ human-facing HTML archive

/category/security/feed/
→ machine-readable feed

RSS feeds are not XML sitemaps

Both are machine-readable, but their purposes differ.

RSS feed
→ content syndication
→ recent updates

XML sitemap
→ URL discovery
→ search-engine crawling

Disabling one does not inherently disable the other.

RSS feeds are not the REST API

Likewise:

/feed/
→ syndication feed

/wp-json/
→ REST API

They use different routing and output systems.

Disabling feeds does not inherently disable REST functionality.

RSS feeds are not XML-RPC

XML-RPC normally uses:

/xmlrpc.php

Feed functionality is separate.

A site can have:

RSS enabled
XML-RPC disabled

or:

RSS disabled
XML-RPC enabled

WordPress feed URLs and SEO

Feeds are primarily syndication resources rather than replacements for normal SEO landing pages.

A category page such as:

/category/security/

is designed as the normal web archive.

Its feed:

/category/security/feed/

exists for feed consumers.

Do not rewrite your internal navigation toward feed URLs

Human-facing navigation should generally link to normal HTML pages unless the link is intentionally labeled as an RSS or feed subscription.

Do not treat every feed URL as unwanted duplicate content

Feeds exist specifically to provide alternate machine-readable representations.

Whether they should remain enabled depends on the site’s syndication requirements, not merely on the fact that another URL exists.

Feeds can still create crawlable surface area

Large WordPress sites can expose many contextual feeds:

hundreds of categories
+
hundreds of tags
+
many authors
+
custom taxonomies
+
searches
+
custom post types

If the website does not use RSS at all, administrators may decide to disable those endpoints deliberately.

See How to Disable RSS Feeds in WordPress.

Hiding feed links is different from disabling feed URLs

If the objective is only:

remove RSS metadata
from <head>

then feed endpoints can stay available.

If the objective is:

no RSS endpoint
should return content

then feed handlers must be addressed too.

See Hiding vs. Disabling WordPress Feeds.

How TheOneWP handles RSS discovery separately

TheOneWP Disable RSS Feed Links removes WordPress’s standard feed-discovery output from the document head.

It targets:

feed_links
feed_links_extra

without disabling the underlying feed URLs.

The result is:

RSS autodiscovery
→ removed

/feed/
→ still available

How TheOneWP handles complete feed shutdown

TheOneWP Disable RSS Feeds handles the broader shutdown case.

The verified implementation blocks the standard native feed handlers for:

RSS
RSS2
RDF
Atom

and returns an HTTP:

404

while also removing the standard WordPress feed-discovery links.

Feed URL audits should test endpoints directly

If you are auditing RSS behavior, do not stop after inspecting page source.

Request the feed itself.

Test with curl

curl -I \
    https://example.com/feed/

or retrieve the actual response body:

curl \
    https://example.com/feed/

Check the HTTP status

An enabled feed normally returns a successful response.

A deliberately disabled configuration may instead return:

404 Not Found

or another intentionally configured status.

Check Content-Type

Feed responses normally use an XML-oriented feed content type rather than:

text/html

from a standard webpage.

If /feed/ returns HTML, investigate why

Possible explanations include:

• a redirect;
• a security plugin;
• a maintenance page;
• a cache rule;
• a feed-disabling plugin;
• server-level routing;
• an application error.

Inspect redirects

Use:

curl -I

to check whether:

/feed/
→ 301
→ another URL

instead of assuming WordPress served the feed directly.

Canonical redirects can normalize feed URLs

WordPress’s canonical routing can redirect non-canonical URL variations toward the preferred form.

If you manually guess a feed URL and WordPress redirects it, use the final generated URL from Core as the authoritative version for your application.

Caches can preserve old feed behavior

Feed responses may be cached by:

• WordPress caching plugins;
• reverse proxies;
• hosting caches;
• CDNs;
• browsers;
• feed readers themselves.

Clear caches before concluding a feed setting failed

If you disable feeds and still receive RSS, determine whether the response came from:

WordPress origin
or
cached response

Test anonymously

Some caching layers bypass cache for logged-in administrators.

Your browser may therefore show one result while external feed readers continue receiving another.

Common mistake: assuming /feed/ is the only feed

WordPress supports contextual feeds for multiple query types.

Common mistake: forgetting the comments feed

Test:

/comments/feed/

separately from:

/feed/

Common mistake: misunderstanding /post-slug/feed/

For a singular post, that URL normally represents the post’s comments feed.

Common mistake: hardcoding category feed URLs

Category bases can be customized.

Use:

get_category_feed_link()

Common mistake: hardcoding author slugs

User nicenames and author bases can differ from assumptions.

Use:

get_author_feed_link()

Common mistake: assuming every custom post type has a feed

The post type must have an appropriate archive and rewrite configuration.

Common mistake: assuming every custom taxonomy uses its internal name in the URL

Rewrite slugs can be different.

Common mistake: forgetting plain permalinks

Feed URLs do not always use:

/feed/

paths.

Common mistake: forcing RSS2 everywhere

Use the default feed unless the application specifically requires a particular format.

Common mistake: treating the Feed URL as a file

There normally is no physical:

/feed/index.xml

file sitting in the web root.

WordPress generates the feed dynamically from its query and template system.

Common mistake: searching the server for a feed folder

Pretty URLs are rewrite routes.

The path:

/category/security/feed/

does not imply a directory structure such as:

/category/
    /security/
        /feed/

on disk.

Common mistake: removing feed discovery and thinking the endpoint disappeared

Discovery metadata and endpoint functionality are independent.

Common mistake: disabling feeds because nobody sees an RSS icon

Integrations can consume feeds without any visible frontend RSS button.

Common mistake: assuming RSS is unused without checking logs

A feed may be requested regularly by an automation that has worked quietly for years, humanity’s preferred documentation system being “someone probably remembers how this works.”

Common mistake: disabling RSS as a security substitute

RSS configuration does not replace:

• authentication;
• authorization;
• updates;
• hardening;
• monitoring.

Common mistake: disabling feeds to stop all scraping

Public HTML remains available to automated clients.

Common mistake: confusing feed URLs with sitemaps

They solve different problems.

Common mistake: editing WordPress Core feed code

Use documented functions, hooks and filters instead.

WordPress RSS feed URL audit checklist

• Check the main /feed/ URL.
• Check the site’s Atom feed.
• Check the RDF feed if relevant.
• Check the legacy RSS feed if relevant.
• Check the site-wide comments feed.
• Check individual post comment feeds.
• Check category feeds.
• Check tag feeds.
• Check author feeds.
• Check search-result feeds.
• Check custom taxonomy feeds.
• Check custom post type archive feeds.
• Check plugin-defined custom feeds.
• Check whether pretty permalinks are enabled.
• Do not assume one URL structure works on every site.
• Use get_feed_link() for the main feed.
• Use get_post_comments_feed_link() for singular comment feeds.
• Use get_category_feed_link() for categories.
• Use get_tag_feed_link() for tags.
• Use get_term_feed_link() for custom taxonomies.
• Use get_author_feed_link() for authors.
• Use get_search_feed_link() for search feeds.
• Use get_post_type_archive_feed_link() for post type archives.
• Handle false return values where applicable.
• Escape URLs before HTML output.
• Check whether plugins filter generated feed URLs.
• Check whether plugins register custom feeds with add_feed().
• Inspect RSS autodiscovery markup separately.
• Remember that discovery and availability are different.
• Check HTTP response codes directly.
• Check redirects.
• Check response Content-Type.
• Clear application cache before testing.
• Clear server cache where relevant.
• Clear CDN cache where relevant.
• Test anonymously.
• Audit feed integrations before disabling anything.
• Document which feed URLs the project intentionally supports.

Related guides

• How to Disable RSS Feeds in WordPress
• Disable RSS Feeds vs. Remove Feed Links
• Hiding vs. Disabling WordPress Feeds
• How WordPress Advertises RSS Feeds by Default
• Cleaning Up WordPress’s Default Head Output

Final recommendation

Do not think of WordPress RSS as one URL.

Think of it as a feed system built around:

WordPress query
+
feed format
+
permalink configuration
=
feed URL

The main:

/feed/

URL normally represents recent posts using RSS2, but WordPress can also generate feeds for:

• site-wide comments;
• individual post comments;
• categories;
• tags;
• custom taxonomy terms;
• authors;
• search queries;
• custom post type archives;
• custom plugin-defined feed types.

When writing code, do not guess those addresses.

Use the appropriate WordPress function:

get_feed_link()

get_post_comments_feed_link()

get_category_feed_link()

get_tag_feed_link()

get_term_feed_link()

get_author_feed_link()

get_search_feed_link()

get_post_type_archive_feed_link()

This lets WordPress account for the current permalink structure, registered rewrite rules, default feed type and relevant URL filters.

Keep another distinction clear:

feed URL
≠
feed discovery link

A URL such as:

/category/security/feed/

can remain fully accessible even when its <link rel="alternate"> autodiscovery element has been removed from the site’s HTML.

If your objective is only to stop WordPress advertising RSS endpoints, use a discovery-level solution such as TheOneWP Disable RSS Feed Links.

If the objective is to stop serving WordPress’s native feed content entirely, TheOneWP Disable RSS Feeds addresses the feed handlers as well and removes the standard discovery output.

Before disabling anything, identify which URLs the site actually exposes and whether readers, newsletters, automation systems or other integrations use them.

The reliable way to understand WordPress feeds is not to memorize every possible URL variation. It is to understand which WordPress query the feed represents and let Core generate the correct address for that resource.