Categories

You can create taxonomies for your entries, users, and assets using Categories.

# Category Groups

Before you can create categories, you must create Category Groups to contain them. Each Category Group lets you define the following:

  • Category Group name
  • Category Group handle (how you’ll refer to the Category Group in your templates)
  • Maximum number of levels you can nest categories in the group
  • The format of the category URI
  • Which template should load if a category’s URL is accessed
  • Which fields categories in the group should have

To create a new category group, go to Settings → Categories and click “New Category Group”.

After you create at least one category group, you will be able to create categories for that group.

# Category Field Layout

Each Category Group can have its own Field Layout, which allows you to customize the data that’s associated with each category in the group. By default, every category will have a Title field (the category name).

You can also add additional fields using all of the available field types in Craft. If a field doesn’t yet exist, you must first create it via Settings → Fields. The new field will then be available to assign to the Field Layout of your Category Group.

# Creating and Editing Categories

When there’s at least one category group, Categories will appear in the primary control panel navigation. Clicking it will take you to the category index. From there, you can choose a category group from the sidebar, and add/reorder/delete categories within it:

Screenshot of the categories index, with “Categories” active in the main navigation, the “Types of Coffee Drinks” category group selected, and a listing of category names in a nested hierarchy

Select the “Structure” sort to work with a drag-and-drop hierarchy: Close crop of a screenshot with an arrow pointing to the “Structure” view option in the menu immediately to the right of the search bar

Double-clicking a category’s status icon opens a slideout for quickly editing that category’s details:

Screenshot of the category listing with a slideout opened for editing the “Americano” category fields

You can also click a category’s title to visit its edit page just like an entry.

When you create a category, you have the following options:

  • Fill out the category fields (if you didn’t define any then the only field available will be Title)
  • Edit the slug (it’s automatically populated based on the title).
  • Choose a Parent category. The new category will have a hierarchical relationship with its parent. This is helpful for creating taxonomies with multiple levels. You also have the option of creating a new category while assigning the Parent.

You can only nest categories up to the level specified in the Max Level field Category Group settings. If it’s empty, the nesting level is unlimited.

# Assigning Categories

To assign categories to things (entries, assets, users, etc.), you must first create a Categories field.

Each Categories field is connected to a single category group. Whatever you attach the field to will be able to create relations to any of the categories within that group.

# Querying Categories

You can fetch categories in your templates or PHP code using category queries.

{# Create a new category query #}
{% set myCategoryQuery = craft.categories() %}

Once you’ve created a category query, you can set parameters on it to narrow down the results, and then execute it by calling .all(). An array of Category (opens new window) objects will be returned.

See Element Queries to learn about how element queries work.

# Example

We can display a navigation for all the categories in a category group called “Topics” by doing the following:

  1. Create a category query with craft.categories().
  2. Set the group parameter on it.
  3. Fetch the categories with .all().
  4. Loop through the categories using a nav tag to create the navigation HTML.
{# Create a category query with the 'group' parameter #}
{% set myCategoryQuery = craft.categories()
  .group('topics') %}

{# Fetch the categories #}
{% set categories = myCategoryQuery.all() %}

{# Display the navigation #}
<ul>
  {% nav category in categories %}
    <li>
      <a href="{{ category.url }}">{{ category.title }}</a>
      {% ifchildren %}
        <ul>
          {% children %}
        </ul>
      {% endifchildren %}
    </li>
  {% endnav %}
</ul>

To maintain the exact order you see in the control panel, add orderBy('lft ASC') to your query:

{% set myCategoryQuery = craft.categories()
  .group('topics')
  .orderBy('lft ASC') %}

# Parameters

Category queries support the following parameters:

Param Description
addOrderBy Adds additional ORDER BY columns to the query.
afterPopulate Performs any post-population processing on elements.
ancestorDist Narrows the query results to only categories that are up to a certain distance away from the category specified by ancestorOf.
ancestorOf Narrows the query results to only categories that are ancestors of another category in its structure.
andRelatedTo Narrows the query results to only categories that are related to certain other elements.
anyStatus Removes element filters based on their statuses.
asArray Causes the query to return matching categories as arrays of data, rather than Category (opens new window) objects.
cache Enables query cache for this Query.
clearCachedResult Clears the cached result (opens new window).
dateCreated Narrows the query results based on the categories’ creation dates.
dateUpdated Narrows the query results based on the categories’ last-updated dates.
descendantDist Narrows the query results to only categories that are up to a certain distance away from the category specified by descendantOf.
descendantOf Narrows the query results to only categories that are descendants of another category in its structure.
fields Returns the list of fields that should be returned by default by toArray() (opens new window) when no specific fields are specified.
fixedOrder Causes the query results to be returned in the order specified by id.
group Narrows the query results based on the category groups the categories belong to.
groupId Narrows the query results based on the category groups the categories belong to, per the groups’ IDs.
hasDescendants Narrows the query results based on whether the categories have any descendants in their structure.
id Narrows the query results based on the categories’ IDs.
ignorePlaceholders Causes the query to return matching categories as they are stored in the database, ignoring matching placeholder elements that were set by craft\services\Elements::setPlaceholderElement() (opens new window).
inReverse Causes the query results to be returned in reverse order.
leaves Narrows the query results based on whether the categories are “leaves” (categories with no descendants).
level Narrows the query results based on the categories’ level within the structure.
limit Determines the number of categories that should be returned.
nextSiblingOf Narrows the query results to only the category that comes immediately after another category in its structure.
offset Determines how many categories should be skipped in the results.
orderBy Determines the order that the categories should be returned in. (If empty, defaults to dateCreated DESC, or the order defined by the category group if the group or groupId params are set to a single group.)
positionedAfter Narrows the query results to only categories that are positioned after another category in its structure.
positionedBefore Narrows the query results to only categories that are positioned before another category in its structure.
preferSites If unique is set, this determines which site should be selected when querying multi-site elements.
prevSiblingOf Narrows the query results to only the category that comes immediately before another category in its structure.
relatedTo Narrows the query results to only categories that are related to certain other elements.
search Narrows the query results to only categories that match a search query.
siblingOf Narrows the query results to only categories that are siblings of another category in its structure.
site Determines which site(s) the categories should be queried in.
siteId Determines which site(s) the categories should be queried in, per the site’s ID.
siteSettingsId Narrows the query results based on the categories’ IDs in the elements_sites table.
slug Narrows the query results based on the categories’ slugs.
status Narrows the query results based on the categories’ statuses.
title Narrows the query results based on the categories’ titles.
trashed Narrows the query results to only categories that have been soft-deleted.
uid Narrows the query results based on the categories’ UIDs.
unique Determines whether only elements with unique IDs should be returned by the query.
uri Narrows the query results based on the categories’ URIs.
with Causes the query to return matching categories eager-loaded with related elements.

# addOrderBy

Adds additional ORDER BY columns to the query.

# afterPopulate

Performs any post-population processing on elements.

# ancestorDist

Narrows the query results to only categories that are up to a certain distance away from the category specified by ancestorOf.

{# Fetch categories above this one #}
{% set categories = craft.categories()
  .ancestorOf(myCategory)
  .ancestorDist(3)
  .all() %}

# ancestorOf

Narrows the query results to only categories that are ancestors of another category in its structure.

Possible values include:

Value Fetches categories…
1 above the category with an ID of 1.
a Category (opens new window) object above the category represented by the object.
{# Fetch categories above this one #}
{% set categories = craft.categories()
  .ancestorOf(myCategory)
  .all() %}

This can be combined with ancestorDist if you want to limit how far away the ancestor categories can be.

# andRelatedTo

Narrows the query results to only categories that are related to certain other elements.

See Relations (opens new window) for a full explanation of how to work with this parameter.

{# Fetch all categories that are related to myCategoryA and myCategoryB #}
{% set categories = craft.categories()
  .relatedTo(myCategoryA)
  .andRelatedTo(myCategoryB)
  .all() %}

# anyStatus

Removes element filters based on their statuses.

{# Fetch all categories, regardless of status #}
{% set categories = craft.categories()
  .anyStatus()
  .all() %}

# asArray

Causes the query to return matching categories as arrays of data, rather than Category (opens new window) objects.

{# Fetch categories as arrays #}
{% set categories = craft.categories()
  .asArray()
  .all() %}

# cache

Enables query cache for this Query.

# clearCachedResult

Clears the cached result (opens new window).

# dateCreated

Narrows the query results based on the categories’ creation dates.

Possible values include:

Value Fetches categories…
'>= 2018-04-01' that were created on or after 2018-04-01.
'< 2018-05-01' that were created before 2018-05-01
['and', '>= 2018-04-04', '< 2018-05-01'] that were created between 2018-04-01 and 2018-05-01.
{# Fetch categories created last month #}
{% set start = date('first day of last month')|atom %}
{% set end = date('first day of this month')|atom %}

{% set categories = craft.categories()
  .dateCreated(['and', ">= #{start}", "< #{end}"])
  .all() %}

# dateUpdated

Narrows the query results based on the categories’ last-updated dates.

Possible values include:

Value Fetches categories…
'>= 2018-04-01' that were updated on or after 2018-04-01.
'< 2018-05-01' that were updated before 2018-05-01
['and', '>= 2018-04-04', '< 2018-05-01'] that were updated between 2018-04-01 and 2018-05-01.
{# Fetch categories updated in the last week #}
{% set lastWeek = date('1 week ago')|atom %}

{% set categories = craft.categories()
  .dateUpdated(">= #{lastWeek}")
  .all() %}

# descendantDist

Narrows the query results to only categories that are up to a certain distance away from the category specified by descendantOf.

{# Fetch categories below this one #}
{% set categories = craft.categories()
  .descendantOf(myCategory)
  .descendantDist(3)
  .all() %}

# descendantOf

Narrows the query results to only categories that are descendants of another category in its structure.

Possible values include:

Value Fetches categories…
1 below the category with an ID of 1.
a Category (opens new window) object below the category represented by the object.
{# Fetch categories below this one #}
{% set categories = craft.categories()
  .descendantOf(myCategory)
  .all() %}

This can be combined with descendantDist if you want to limit how far away the descendant categories can be.

# fields

Returns the list of fields that should be returned by default by toArray() (opens new window) when no specific fields are specified.

A field is a named element in the returned array by toArray() (opens new window). This method should return an array of field names or field definitions. If the former, the field name will be treated as an object property name whose value will be used as the field value. If the latter, the array key should be the field name while the array value should be the corresponding field definition which can be either an object property name or a PHP callable returning the corresponding field value. The signature of the callable should be:

function ($model, $field) {
    // return field value
}

For example, the following code declares four fields:

  • email: the field name is the same as the property name email;
  • firstName and lastName: the field names are firstName and lastName, and their values are obtained from the first_name and last_name properties;
  • fullName: the field name is fullName. Its value is obtained by concatenating first_name and last_name.
return [
    'email',
    'firstName' => 'first_name',
    'lastName' => 'last_name',
    'fullName' => function ($model) {
        return $model->first_name . ' ' . $model->last_name;
    },
];

# fixedOrder

Causes the query results to be returned in the order specified by id.

If no IDs were passed to id, setting this to true will result in an empty result set.

{# Fetch categories in a specific order #}
{% set categories = craft.categories()
  .id([1, 2, 3, 4, 5])
  .fixedOrder()
  .all() %}

# group

Narrows the query results based on the category groups the categories belong to.

Possible values include:

Value Fetches categories…
'foo' in a group with a handle of foo.
'not foo' not in a group with a handle of foo.
['foo', 'bar'] in a group with a handle of foo or bar.
['not', 'foo', 'bar'] not in a group with a handle of foo or bar.
a CategoryGroup (opens new window) object in a group represented by the object.
{# Fetch categories in the Foo group #}
{% set categories = craft.categories()
  .group('foo')
  .all() %}

# groupId

Narrows the query results based on the category groups the categories belong to, per the groups’ IDs.

Possible values include:

Value Fetches categories…
1 in a group with an ID of 1.
'not 1' not in a group with an ID of 1.
[1, 2] in a group with an ID of 1 or 2.
['not', 1, 2] not in a group with an ID of 1 or 2.
{# Fetch categories in the group with an ID of 1 #}
{% set categories = craft.categories()
  .groupId(1)
  .all() %}

# hasDescendants

Narrows the query results based on whether the categories have any descendants in their structure.

(This has the opposite effect of calling leaves.)

{# Fetch categories that have descendants #}
{% set categories = craft.categories()
  .hasDescendants()
  .all() %}

# id

Narrows the query results based on the categories’ IDs.

Possible values include:

Value Fetches categories…
1 with an ID of 1.
'not 1' not with an ID of 1.
[1, 2] with an ID of 1 or 2.
['not', 1, 2] not with an ID of 1 or 2.
{# Fetch the category by its ID #}
{% set category = craft.categories()
  .id(1)
  .one() %}

This can be combined with fixedOrder if you want the results to be returned in a specific order.

# ignorePlaceholders

Causes the query to return matching categories as they are stored in the database, ignoring matching placeholder elements that were set by craft\services\Elements::setPlaceholderElement() (opens new window).

# inReverse

Causes the query results to be returned in reverse order.

{# Fetch categories in reverse #}
{% set categories = craft.categories()
  .inReverse()
  .all() %}

# leaves

Narrows the query results based on whether the categories are “leaves” (categories with no descendants).

(This has the opposite effect of calling hasDescendants.)

{# Fetch categories that have no descendants #}
{% set categories = craft.categories()
  .leaves()
  .all() %}

# level

Narrows the query results based on the categories’ level within the structure.

Possible values include:

Value Fetches categories…
1 with a level of 1.
'not 1' not with a level of 1.
'>= 3' with a level greater than or equal to 3.
[1, 2] with a level of 1 or 2
['not', 1, 2] not with level of 1 or 2.
{# Fetch categories positioned at level 3 or above #}
{% set categories = craft.categories()
  .level('>= 3')
  .all() %}

# limit

Determines the number of categories that should be returned.

{# Fetch up to 10 categories  #}
{% set categories = craft.categories()
  .limit(10)
  .all() %}

# nextSiblingOf

Narrows the query results to only the category that comes immediately after another category in its structure.

Possible values include:

Value Fetches the category…
1 after the category with an ID of 1.
a Category (opens new window) object after the category represented by the object.
{# Fetch the next category #}
{% set category = craft.categories()
  .nextSiblingOf(myCategory)
  .one() %}

# offset

Determines how many categories should be skipped in the results.

{# Fetch all categories except for the first 3 #}
{% set categories = craft.categories()
  .offset(3)
  .all() %}

# orderBy

Determines the order that the categories should be returned in. (If empty, defaults to dateCreated DESC, or the order defined by the category group if the group or groupId params are set to a single group.)

{# Fetch all categories in order of date created #}
{% set categories = craft.categories()
  .orderBy('dateCreated ASC')
  .all() %}

# positionedAfter

Narrows the query results to only categories that are positioned after another category in its structure.

Possible values include:

Value Fetches categories…
1 after the category with an ID of 1.
a Category (opens new window) object after the category represented by the object.
{# Fetch categories after this one #}
{% set categories = craft.categories()
  .positionedAfter(myCategory)
  .all() %}

# positionedBefore

Narrows the query results to only categories that are positioned before another category in its structure.

Possible values include:

Value Fetches categories…
1 before the category with an ID of 1.
a Category (opens new window) object before the category represented by the object.
{# Fetch categories before this one #}
{% set categories = craft.categories()
  .positionedBefore(myCategory)
  .all() %}

# preferSites

If unique is set, this determines which site should be selected when querying multi-site elements.

For example, if element “Foo” exists in Site A and Site B, and element “Bar” exists in Site B and Site C, and this is set to ['c', 'b', 'a'], then Foo will be returned for Site B, and Bar will be returned for Site C.

If this isn’t set, then preference goes to the current site.

{# Fetch unique categories from Site A, or Site B if they don’t exist in Site A #}
{% set categories = craft.categories()
  .site('*')
  .unique()
  .preferSites(['a', 'b'])
  .all() %}

# prevSiblingOf

Narrows the query results to only the category that comes immediately before another category in its structure.

Possible values include:

Value Fetches the category…
1 before the category with an ID of 1.
a Category (opens new window) object before the category represented by the object.
{# Fetch the previous category #}
{% set category = craft.categories()
  .prevSiblingOf(myCategory)
  .one() %}

# relatedTo

Narrows the query results to only categories that are related to certain other elements.

See Relations (opens new window) for a full explanation of how to work with this parameter.

{# Fetch all categories that are related to myCategory #}
{% set categories = craft.categories()
  .relatedTo(myCategory)
  .all() %}

Narrows the query results to only categories that match a search query.

See Searching (opens new window) for a full explanation of how to work with this parameter.

{# Get the search query from the 'q' query string param #}
{% set searchQuery = craft.app.request.getQueryParam('q') %}

{# Fetch all categories that match the search query #}
{% set categories = craft.categories()
  .search(searchQuery)
  .all() %}

# siblingOf

Narrows the query results to only categories that are siblings of another category in its structure.

Possible values include:

Value Fetches categories…
1 beside the category with an ID of 1.
a Category (opens new window) object beside the category represented by the object.
{# Fetch categories beside this one #}
{% set categories = craft.categories()
  .siblingOf(myCategory)
  .all() %}

# site

Determines which site(s) the categories should be queried in.

The current site will be used by default.

Possible values include:

Value Fetches categories…
'foo' from the site with a handle of foo.
['foo', 'bar'] from a site with a handle of foo or bar.
['not', 'foo', 'bar'] not in a site with a handle of foo or bar.
a craft\models\Site (opens new window) object from the site represented by the object.
'*' from any site.

If multiple sites are specified, elements that belong to multiple sites will be returned multiple times. If you only want unique elements to be returned, use unique in conjunction with this.

{# Fetch categories from the Foo site #}
{% set categories = craft.categories()
  .site('foo')
  .all() %}

# siteId

Determines which site(s) the categories should be queried in, per the site’s ID.

The current site will be used by default.

Possible values include:

Value Fetches categories…
1 from the site with an ID of 1.
[1, 2] from a site with an ID of 1 or 2.
['not', 1, 2] not in a site with an ID of 1 or 2.
'*' from any site.
{# Fetch categories from the site with an ID of 1 #}
{% set categories = craft.categories()
  .siteId(1)
  .all() %}

# siteSettingsId

Narrows the query results based on the categories’ IDs in the elements_sites table.

Possible values include:

Value Fetches categories…
1 with an elements_sites ID of 1.
'not 1' not with an elements_sites ID of 1.
[1, 2] with an elements_sites ID of 1 or 2.
['not', 1, 2] not with an elements_sites ID of 1 or 2.
{# Fetch the category by its ID in the elements_sites table #}
{% set category = craft.categories()
  .siteSettingsId(1)
  .one() %}

# slug

Narrows the query results based on the categories’ slugs.

Possible values include:

Value Fetches categories…
'foo' with a slug of foo.
'foo*' with a slug that begins with foo.
'*foo' with a slug that ends with foo.
'*foo*' with a slug that contains foo.
'not *foo*' with a slug that doesn’t contain foo.
['*foo*', '*bar*'] with a slug that contains foo or bar.
['not', '*foo*', '*bar*'] with a slug that doesn’t contain foo or bar.
{# Get the requested category slug from the URL #}
{% set requestedSlug = craft.app.request.getSegment(3) %}

{# Fetch the category with that slug #}
{% set category = craft.categories()
  .slug(requestedSlug|literal)
  .one() %}

# status

Narrows the query results based on the categories’ statuses.

Possible values include:

Value Fetches categories…
'enabled' (default) that are enabled.
'disabled' that are disabled.
['not', 'disabled'] that are not disabled.
{# Fetch disabled categories #}
{% set categories = craft.categories()
  .status('disabled')
  .all() %}

# title

Narrows the query results based on the categories’ titles.

Possible values include:

Value Fetches categories…
'Foo' with a title of Foo.
'Foo*' with a title that begins with Foo.
'*Foo' with a title that ends with Foo.
'*Foo*' with a title that contains Foo.
'not *Foo*' with a title that doesn’t contain Foo.
['*Foo*', '*Bar*'] with a title that contains Foo or Bar.
['not', '*Foo*', '*Bar*'] with a title that doesn’t contain Foo or Bar.
{# Fetch categories with a title that contains "Foo" #}
{% set categories = craft.categories()
  .title('*Foo*')
  .all() %}

# trashed

Narrows the query results to only categories that have been soft-deleted.

{# Fetch trashed categories #}
{% set categories = craft.categories()
  .trashed()
  .all() %}

# uid

Narrows the query results based on the categories’ UIDs.

{# Fetch the category by its UID #}
{% set category = craft.categories()
  .uid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
  .one() %}

# unique

Determines whether only elements with unique IDs should be returned by the query.

This should be used when querying elements from multiple sites at the same time, if “duplicate” results is not desired.

{# Fetch unique categories across all sites #}
{% set categories = craft.categories()
  .site('*')
  .unique()
  .all() %}

# uri

Narrows the query results based on the categories’ URIs.

Possible values include:

Value Fetches categories…
'foo' with a URI of foo.
'foo*' with a URI that begins with foo.
'*foo' with a URI that ends with foo.
'*foo*' with a URI that contains foo.
'not *foo*' with a URI that doesn’t contain foo.
['*foo*', '*bar*'] with a URI that contains foo or bar.
['not', '*foo*', '*bar*'] with a URI that doesn’t contain foo or bar.
{# Get the requested URI #}
{% set requestedUri = craft.app.request.getPathInfo() %}

{# Fetch the category with that URI #}
{% set category = craft.categories()
  .uri(requestedUri|literal)
  .one() %}

# with

Causes the query to return matching categories eager-loaded with related elements.

See Eager-Loading Elements (opens new window) for a full explanation of how to work with this parameter.

{# Fetch categories eager-loaded with the "Related" field’s relations #}
{% set categories = craft.categories()
  .with(['related'])
  .all() %}
Parts of this page are generated or assembled by automations. While we greatly appreciate contributions to the documentation, reporting automated content issues will allow us to fix them at the source!