Skip to content
  • Documentation >
  • API >
  • GraphQL >
  • GraphQL queries

GraphQL queries

Querying content

You can query a single content item or a list of content items using fields defined in the domain schema.

Get a content item

To get a specific content item by its content ID, location ID, or URL alias, use its relevant singular field, for example article, folder, or image.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
{
  content {
    article (contentId: 62) {
      title
      author {
        name
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  "data": {
    "content": {
      "article": {
        "title": "Travel literature, how to get started",
        "author": [
          {
            "name": "Administrator User"
          }
        ]
      }
    }
  }
}

You can request any fields of the content item. In the example above, these are title and author.

You can also query the generic item object. The item object references a content item, but you can also get its location information. The query accepts locationId, remoteId, and urlAlias as arguments.

1
2
3
4
5
{
  item (locationId: 2) {
    _name
  }
}

Response:

1
2
3
4
5
6
7
{
  "data": {
    "item": {
      "_name": "Ibexa Digital Experience Platform"
    }
  }
}

Get language versions

To get fields of a content item in a specific language, use the language argument. The language must be configured for the current SiteAccess.

1
2
3
4
5
6
7
8
{
  content {
    article(id: 57) {
      title: title(language: eng_GB)
      title_PL: title(language: pol_PL)
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
{
  "data": {
    "content": {
      "article": {
        "title": "Most interesting cat breeds",
        "title_PL": "Najciekawsze rasy kotów"
      }
    }
  }
}

When you don't specify a language, the response contains the most prioritized translation.

Get a group of content items

To get a list of all content items of a selected type, use the plural field, for example, articles:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
  content {
    articles {
      edges {
        node {
          _location {
            id
          }
          title
          author {
            name
          }
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
{
  "data": {
    "content": {
      "articles": {
        "edges": [
          {
            "node": {
              "_location": {
                "id": 57
              },
              "title": "Travel literature, How to get started",
              "author": [
                {
                  "name": "Administrator User"
                }
              ]
            }
          },
          {
            "node": {
              "_location": {
                "id": 58
              },
              "title": "Why we love NYC",
              "author": [
                {
                  "name": "Administrator User"
                }
              ]
            }
          },
          # ...
        ]
      }
    }
  }
}

Edges

edges are used when querying plural fields to offer pagination.

Get content type information

To get the IDs and names of all Fields in the article content type:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  content {
    _types {
      article{
        _info {
          fieldDefinitions{
            id
            name
          }
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
{
  "data": {
    "content": {
      "_types": {
        "article": {
          "_info": {
            "fieldDefinitions": [
              {
                "id": 1,
                "name": "Title"
              },
              {
                "id": 152,
                "name": "Short title"
              },
              {
                "id": 153,
                "name": "Author"
              },
              {
                "id": 120,
                "name": "Intro"
              },
              {
                "id": 121,
                "name": "Body"
              },
              {
                "id": 123,
                "name": "Enable comments"
              },
              {
                "id": 154,
                "name": "Image"
              }
            ]
          }
        }
      }
    }
  }
}

Querying Locations

You can get the Location object from any item by querying for _location or _allLocations. When you use _location, the API returns:

  • the location specified in the locationId or urlAlias argument
  • the location based on the current SiteAccess
  • the main location
1
2
3
4
5
6
7
8
9
{
  content {
    folder (contentId: 133) {
      _allLocations {
        pathString
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
{
  "data": {
    "content": {
      "folder": {
        "_allLocations": [
          {
            "pathString": "/1/2/128/132/"
          },
          {
            "pathString": "/1/2/133/"
          }
        ]
      }
    }
  }
}

To query the URL alias of a content item, use _url. This returns the "best" URL alias for this content item based on its main Location and the current SiteAccess:

1
2
3
4
5
6
7
{
  content {
    folder (contentId: 1) {
      _url
    }
  }
}

Response:

1
2
3
4
5
6
7
8
9
{
  "data": {
    "content": {
      "folder": {
        "_url": "/site/ez-platform"
      }
    }
  }
}

Getting children of a Location

To get a location's children, it's recommended to use the Query field.

Alternatively, you can query the children property of an item or content object:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
  item (locationId: 2) {
    _location{
      children {
        edges {
          node {
            content {
              _name
              _type {
                name
              }
            }
          }
        }
      }
    }
  }
}
Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
{
  "data": {
    "item": {
      "_location": {
        "children": {
          "edges": [
            {
              "node": {
                "content": {
                  "_name": "Ibexa Platform",
                  "_type": {
                    "name": "Folder"
                  }
                }
              }
            },
            {
              "node": {
                "content": {
                  "_name": "Product Catalog",
                  "_type": {
                    "name": "Product catalog"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }

Querying products

You can query a single product, products of one type, or all products by providing criteria.

Note

GraphQL schema for product catalog is generated only when at least one product type exists in the system. If your queries fail, make sure you regenerated the schema.

To get a single product by its code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
  products {
    single(code: "DRESUN") {
      name
      productType {name}
      createdAt {
        timestamp
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
{
  "data": {
    "products": {
      "single": {
        "name": "Sundress",
        "productType": {
          "name": "Dress"
        },
        "createdAt": {
          "timestamp": 1649229733
        }
      }
    }
  }
}

To get products of a specific type:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  products {
    byType {
      dresses {
        edges {
          node {
            name
            code
          }
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
  "data": {
    "products": {
      "byType": {
        "dresses": {
          "edges": [
            {
              "node": {
                "name": "Sundress",
                "code": "DRESUN"
              }
            },
            {
              "node": {
                "name": "Cocktail dress",
                "code": "DRECO"
              }
            }
          ]
        }
      },
    }
  }
}

To get all products, using specific criteria (in this case, unavailable products):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
{
  products {
    all(
      availability:unavailable
        sortBy: [name]
    ) {
      edges {
        node {
          name
          code
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
  "data": {
    "products": {
      "all": {
        "edges": [
          {
            "node": {
              "name": "Cocktail dress",
              "code": "DRECO"
            }
          },
          {
            "node": {
              "name": "Sundress",
              "code": "DRESUN"
            }
          }
        ]
      }
    }
  }
}

Filtering

To get all articles with a specific text:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
  content {
    articles(query: {Text:"travel"}) {
      edges {
        node {
          title
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
{
  "data": {
    "content": {
      "articles": {
        "edges": [
          {
            "node": {
              "title": "Travel literature, How to get started"
            }
          },
          {
            "node": {
              "title": "Travel with your dog"
            }
          }
        ]
      }
    }
  }
}

To filter products based on content fields:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
  products {
    all {
      edges {
        node {
          fields {
            ... on DressContentFields {
              name
              description {
                plaintext
              }
            }
            _all {
              fieldDefIdentifier
              value
            }
          }
        }
      }
    }
  }
}

Querying product attributes

To filter products based on attributes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
  products {
    single(code: "BLUELACE") {
      attributes {
        ... on DressAttributes {
          measure {
            reason
          }
          lace_color {
            identifier
            value
          }
        }
      }
    }
  }
}

If the attribute type (in this case, measure) cannot be found in the schema, the response is:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
  "data": {
    "products": {
      "single": {
        "attributes": {
          "measure": {
            "reason": "This attribute type isn't yet part of the schema."
          },
          "lace_color": {
            "identifier": "lace_color",
            "value": "#387be8"
          }
        }
      }
    }
  }
}

You can also query attributes by providing the attribute type:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
  products {
    all {
      edges {
        node {
          attributes {
            _all {
              ... on ColorAttribute {
                identifier
                name
                colorValue: value
              }
              ... on IntegerAttribute {
                identifier
                name
                sizeValue: value
              }
            }
          }
        }
      }
    }
  }
}

Note

You need to use aliases (for example, sizeValue) when querying attributes by the attribute type due to the conflicting return types.

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
{
  "data": {
    "products": {
      "all": {
        "edges": [
          {
            "node": {
              "attributes": {
                "_all": [
                  {
                    "identifier": "size",
                    "name": "Size",
                    "sizeValue": 36
                  },
                  {
                    "identifier": "color",
                    "name": "Color",
                    "colorValue": "#fcff38"
                  }
                ]
              }
            }
          },
          {
            "node": {
              "attributes": {
                "_all": [
                  {
                    "identifier": "color",
                    "name": "Color",
                    "colorValue": "#000000"
                  },
                  {
                    "identifier": "size",
                    "name": "Size",
                    "sizeValue": 40
                  }
                ]
              }
            }
          }
        ]
      }
    }
  }
}

Sorting

You can sort query results using sortBy:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
  content {
    articles(sortBy: _datePublished) {
      edges {
        node {
          title
        }
      }
    }
  }
}

You can use an array of clauses as well. To reverse the item list, add _desc after the clause:

1
articles(sortBy:[_datePublished,_desc])

Pagination

GraphQL offers cursor-based pagination for paginating query results.

You can paginate plural fields by using edges:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
{
  content {
    articles(sortBy: _datePublished, first:3) {
      pageInfo {
        hasNextPage
        endCursor
      }
      edges {
        node {
          title
        }
      }
    }
  }
}

This query returns the first three articles, ordered by their publication date. If the current Connection (list of results) isn't finished yet and there are more items to read, hasNextPage is true.

For the children node, you can use the following pagination method:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
  _repository {
    location(locationId: 2) {
      children(first: 3) {
        pages {
          number
          cursor
        }
        edges {
          node {
            content {
              _name
            }
          }
        }
      }
    }
  }
}

Response:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "data": {
    "_repository": {
      "location": {
        "children": {
          "pages": [
            {
              "number": 2,
              "cursor": "YXJyYXljb25uZWN0aW9uOjE="
            },
            {
              "number": 3,
              "cursor": "YXJyYXljb25uZWN0aW9uOjM="
            }
          ],
          "edges": [
            {
              # ...
            }
          ]
        }
      }
    }
  }
}

In the response, number contains page numbers, starting with 2 (because 1 is the default).

To request a specific page, provide the cursor as an argument to children:

1
children(first: 3, after: "YXJyYXljb25uZWN0aW9uOjM=")

Get Matrix field type

To get a Matrix field type with GraphQL, see Matrix field type reference.