> ## Documentation Index
> Fetch the complete documentation index at: https://buttercms.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get a single Page

> Retrieve a specific page by page type and slug. Use the wildcard * as the page type for Single Pages.

Retrieve a specific page by its page type and slug. This endpoint is ideal for fetching individual pages for display on your website or application.

**Page Type Flexibility**: You can search across all page types using `*` as a wildcard, or optimize your query by providing a specific page type slug. Using the wildcard is useful when you know the page slug but aren't certain of its type, while specifying the page type can improve query performance. Use dotted notation for field filters (e.g., `fields.title=Example`).
See also: Architecture & Performance for guidance on `levels`, pagination, and performance best practices.


## OpenAPI

````yaml /api/openapi/read_api.yaml get /pages/{page_type}/{page_slug}/
openapi: 3.1.0
info:
  title: ButterCMS Read API
  version: 2.0.0
  description: >
    Read endpoints for the ButterCMS API — Pages, Collections, Blog Posts, Blog
    Metadata, and Feeds.
  contact:
    email: support@buttercms.com
  license:
    name: ButterCMS Terms of Service
    url: https://buttercms.com/terms/
servers:
  - url: https://api.buttercms.com/v2
    description: ButterCMS API v2
security:
  - readTokenAuthHeader: []
  - readTokenAuthQuery: []
tags:
  - name: Pages
    description: >
      Retrieve pages from your ButterCMS account.


      **Single Pages**: Use `*` as the page_type to get Single Pages (those
      without a Page Type) which represent unique pages on your site like your
      Homepage. Useful for creating your sitemap.xml.


      **Page Type Pages**: Use the actual page type slug to get pages of that
      specific type. Page Types allow you to create many pages with the same
      structure.


      **Note:** The fields of a page are defined by you, they are customizable.
      Sample responses below contain a basic set of fields for illustrative
      purposes.
  - name: Collections
    description: >
      Retrieve collection items from your ButterCMS account. Collections are
      flexible, user-defined content structures with completely customizable
      field schemas.


      See also: Architecture & Performance for guidance on `levels`, pagination,
      and performance best practices.
  - name: Blog posts
    description: >
      Retrieve blog posts from your ButterCMS account. List blog posts with
      pagination and filtering options, or retrieve individual posts by slug.
  - name: Blog metadata
    description: >
      Retrieve blog-related metadata including authors, categories, and tags.
      These endpoints provide access to the organizational structure of your
      blog content.
  - name: Feeds and utilities
    description: >
      Generate XML feeds for content syndication and SEO.


      - **RSS Feed**: Fully generated RSS 2.0 feed for your blog

      - **Atom Feed**: Standards-compliant Atom 1.0 feed

      - **Sitemap**: XML sitemap for search engine discovery


      All feeds can be filtered by category or tag and include only published
      content from your organization.
  - name: Images - Info
    description: >
      ButterCMS has an integration with
      [Filestack](https://www.filestack.com/docs/api/processing/) for image
      transformations. You can leverage their robust set of image transformation
      capabilities.


      After you upload an image, to create a thumbnail, here's an example:


      - **Original URL**: `https://cdn.buttercms.com/3ccPHhYHTNK2zQ14gCOy`

      - **Thumbnail URL**:
      `https://cdn.buttercms.com/resize=width:100,height:100/3ccPHhYHTNK2zQ14gCOy`


      For complete transformation options and parameters, see the [full
      Filestack documentation](https://www.filestack.com/docs/api/processing/).
paths:
  /pages/{page_type}/{page_slug}/:
    get:
      tags:
        - Pages
      summary: Get a single Page
      description: >
        Retrieve a specific page by its page type and slug. This endpoint is
        ideal for fetching individual pages for display on your website or
        application.


        **Page Type Flexibility**: You can search across all page types using
        `*` as a wildcard, or optimize your query by providing a specific page
        type slug. Using the wildcard is useful when you know the page slug but
        aren't certain of its type, while specifying the page type can improve
        query performance. Use dotted notation for field filters (e.g.,
        `fields.title=Example`).

        See also: Architecture & Performance for guidance on `levels`,
        pagination, and performance best practices.
      operationId: getSinglePage
      parameters:
        - name: page_type
          in: path
          description: |
            The type of page to retrieve.

            - Use `*` to search across all page types
            - Use a specific page type slug to limit search to that type
          required: true
          schema:
            type: string
          examples:
            wildcard:
              value: '*'
              description: Search across all page types
            specific_type:
              value: news
              description: Search within news page type only
        - name: page_slug
          in: path
          description: |
            The slug of the page to retrieve.
          required: true
          schema:
            type: string
          example: example-news-page
        - $ref: '#/components/parameters/preview'
        - $ref: '#/components/parameters/locale'
        - $ref: 43ca77a3-2fdc-4e00-a9e8-459d3b50cfc0
        - $ref: e37f56db-252c-4d03-80b7-ce2afd7eaaae
        - $ref: '#/components/parameters/auth_token'
      responses:
        '200':
          description: >
            **Success**


            A hash with a `data` property that contains the page matching the
            page slug.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SinglePageResponse'
              examples:
                basic_page:
                  summary: Basic page response
                  value:
                    data:
                      slug: example-news-page
                      name: Example News Page
                      page_type: news
                      published: '2019-11-12T17:23:53.109696Z'
                      updated: '2020-10-22T20:07:52.965850Z'
                      fields:
                        seo:
                          title: Example News Page
                          description: SEO Description
                          keywords: SEO, Keywords
                        headline: This is an example news page
                        sections:
                          - fields:
                              headline: ...
                              subheadline: ...
                              call_to_action: ...
                            type: hero
                          - fields:
                              video_headline: ...
                              video_link: ...
                            type: product_video
                media_url_format:
                  summary: Media field as URL string (alt_media_text=0)
                  description: >-
                    When `alt_media_text=0` (default), media fields are returned
                    as URL strings.
                  value:
                    data:
                      slug: poster-page
                      name: Poster Page
                      page_type: posters
                      published: '2020-01-01T10:00:00Z'
                      updated: '2020-01-02T10:00:00Z'
                      fields:
                        title: Poster Details
                        media: https://cdn.example.com/media/poster.jpg
                media_object_format:
                  summary: Media field as object (alt_media_text=1)
                  description: >
                    When `alt_media_text=1`, media fields are returned as
                    objects. The object always includes `url`, and `alt` is
                    included when available.
                  value:
                    data:
                      slug: poster-page
                      name: Poster Page
                      page_type: posters
                      published: '2020-01-01T10:00:00Z'
                      updated: '2020-01-02T10:00:00Z'
                      fields:
                        title: Poster Details
                        media:
                          url: https://cdn.example.com/media/poster.jpg
                          alt: Movie poster artwork
        '400':
          description: |
            **Bad Request - Invalid Parameter**

            Invalid parameter value provided. This can happen when:
            - The `levels` parameter is not a valid integer between 1 and 5
            - Invalid locale parameter provided
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                invalid_levels:
                  summary: Invalid levels parameter
                  value:
                    detail: >-
                      levels query parameter should be an integer between 1 and
                      5 (inclusive)
                invalid_locale:
                  summary: Invalid locale parameter
                  value:
                    detail: Invalid locale parameter
        '401':
          description: >
            **Unauthorized - Invalid or Missing API Token**


            Authentication credentials were not provided. Make sure to include
            your read API token in the `Authorization` header or as the
            `auth_token` query parameter.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                detail: Authentication credentials were not provided
        '403':
          description: >
            **Forbidden - Multiple Pages Found**


            Multiple pages were found with the same slug when using wildcard
            page type. This typically indicates a data integrity issue where the
            same slug exists across different page types.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                detail: >-
                  Multiple pages found with the same slug. Please specify a page
                  type or contact support.
        '404':
          description: >
            **Not Found - Page Does Not Exist**


            The requested page doesn't exist, or you don't have access to it.
            This could be because:

            - The page slug doesn't exist

            - The page type doesn't exist

            - The page exists but not in the specified page type
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                page_not_found:
                  summary: Page not found
                  value:
                    detail: Page not found.
                page_type_not_found:
                  summary: Page type not found
                  value:
                    detail: Page type not found.
      security:
        - readTokenAuthHeader: []
        - readTokenAuthQuery: []
components:
  parameters:
    preview:
      name: preview
      in: query
      description: >
        Set to 1 to return the latest draft version of a page. Useful for
        previewing changes before publishing live. i.e. `&preview=1`. If you are
        trying to view a scheduled page for which the most recent page version
        is published, you must pass the preview parameter to see the scheduled
        changes.


        Set to `1` to access unpublished/draft collection items. Useful for
        staging environments.
      required: false
      schema:
        type: integer
        enum:
          - 0
          - 1
        default: 0
      example: 1
    locale:
      name: locale
      in: query
      description: >
        Set to the api slug of your configured locale (e.g. `en` or `fr`). When
        omitted, this query parameter will default to your organization's
        default locale.
      required: false
      schema:
        type: string
        maxLength: 10
        example: en
      examples:
        english:
          value: en
          description: English locale
        spanish:
          value: es
          description: Spanish locale
        french:
          value: fr
          description: French locale
    auth_token:
      name: auth_token
      in: query
      required: false
      schema:
        type: string
      description: |
        Your ButterCMS read API token
      example: your_api_token
  schemas:
    SinglePageResponse:
      type: object
      properties:
        data:
          $ref: '#/components/schemas/PageObject'
    ErrorResponse:
      type: object
      properties:
        detail:
          type: string
          description: Error message describing what went wrong
          example: Authentication credentials were not provided
    PageObject:
      type: object
      description: A single page object that can be either a Single Page or Page Type page
      properties:
        slug:
          type: string
          description: Unique identifier
          example: example-news-page
        name:
          type: string
          description: Name of the Page
          example: Example News Page
        page_type:
          type:
            - string
            - 'null'
          description: >-
            API slug identifier of the page_type for the Page. null for Single
            Pages
          example: news
        published:
          type:
            - string
            - 'null'
          format: date-time
          description: Timestamp of when the page was first published
          example: '2019-11-12T17:23:53.109696Z'
        updated:
          type: string
          format: date-time
          description: Timestamp of when the page was most recently published
          example: '2020-10-22T20:07:52.965850Z'
        scheduled:
          type:
            - string
            - 'null'
          format: date-time
          description: >-
            Timestamp of when the page is scheduled to be published. If not
            scheduled, this field will be null
          example: null
        status:
          type: string
          enum:
            - published
            - draft
            - scheduled
          description: Status of the current version of the page
          example: published
        fields:
          type: object
          description: >-
            Contains all of the actual content for the Page - fields are
            customizable
          additionalProperties: true
          example:
            seo:
              title: Example News Page
              description: SEO Description
              keywords: SEO, Keywords
            headline: This is an example news page
            sections:
              - fields:
                  headline: ...
                  subheadline: ...
                  call_to_action: ...
                type: hero
  securitySchemes:
    readTokenAuthHeader:
      type: apiKey
      in: header
      name: Authorization
      description: |
        Set the `Authorization` header to `Token your_read_api_token`.

        Example: `Authorization: Token abc123def456`

        Note: The header value includes the `Token` prefix.

        You can access your API token from your settings page.
    readTokenAuthQuery:
      type: apiKey
      in: query
      name: auth_token
      description: >
        Pass your API token via the `auth_token` parameter on every request:
        `?auth_token=your_read_api_token`.


        You can access your API token from your settings page.


        Requests made with a missing or invalid token will get a 401
        Unauthorized response. All requests must be made over HTTPS.

````