Query Items

get

/content/management/api/v1.1/items

This resource enables filtering of management content by query. You can control the number of items to be fetched, paginated, and sorted. Additionally, this resource can fetch field values of matching items.
Query expression syntax supports conditions that match the field values. A NOT operator is supported and negates the results of matches it applies to - e.g. NOT (type eq "Type1"). Note that the space between the NOT and the following opening brace is required. You can also query across all fields for a specific phrase. Many such query conditions can be joined by using AND/OR operators and grouped with parentheses.

Query expression ?q=(type eq "Employee" AND (fields.emails co "example.com" OR fields.emails co "example.org"))
Query expression usage with this resource /management/api/v1.1/items?q=(type eq "Employee" AND (fields.emails co "example.com" OR fields.emails co "example.org"))

Notes: Field names used in the Query are case-sensitive.

In general, two forms of filtering are supported by this resource.
  • Query within a type: Query within a type allows query conditions that apply to fields of the type.
    For example:
    /management/api/v1.1/items?q=(type eq "Employee" AND fields.role eq "Senior Developer")
    Here, role is a field of type Employee.
    Two level deep searches (typed searches only):
    Fields on first level reference fields of an item may also be searched, effectively providing a way to delve two levels deep into an item's field hierarchy. The second level provides the same semantics as those provided during searching fields of an item. Searching recursively down an item's reference hierarchy past the first level is not supported. Sorting by second level fields is not supported.
    For example:
    /management/api/v1.1/items?q=(type eq "Employee" AND fields.address.street eq "Main St")
    Here, 'address' is the name of a reference type field on type 'Employee' that in turn has a field with name 'street'.
  • Query across types: When no type is specified in the query, all types are queried. Also, multi type query is allowed and it comes under Global query. However, query conditions are limited to standard fields (id, type, name, description, slug, translatable, language, createdBy, createdDate, updatedBy, updatedDate, repositoryId, channels, collections, status, tags, isPublished, languageIsMaster, taxonomies) only.
    For example:
    /management/api/v1.1/items?q=(name eq "John") or /management/api/v1.1/items?q=(description co "users")

In either form, it is possible to search by matching anywhere (any field) by specifying a default match criteria. Such criteria are specified in a generic query that matches values of the items across all fields.
For example:
/management/api/v1.1/items?default="coffee"
/management/api/v1.1/items?q=(type eq "Employee"&default="senior")

In either form, while querying using standard fields, name, description, type, slug, language, status are to be considered as a text data type (single valued), id, repositoryId as a reference data type (single valued), createdDate, updatedDate as a datetime data type (single valued), translatable, isPublished, languageIsMaster as a boolean data type (single valued) and collections, channels, tags, taxonomies, suggestedTaxonomies as a reference data type (multi valued)

OperatorExampleSupported data typesDescription
eq?q=(name eq "John")

?q=(type eq "DigitalAsset")

?q=(type eq "Employee" and fields.DOB eq "1994/09/26T16:23:45.208")

?q=(taxonomies.categories.id eq "B9F568DC43C54803AC76012783FA5101")

?q=(taxonomies.categories.name eq "cars")

?q=(taxonomies.categories.apiName eq "cars-unique")

?q=(taxonomies.categories.nodes.id eq "B9F568DC43C54803AC76012783FA5101")

?q=(taxonomies.categories.nodes.name eq "cars")

?q=(taxonomies.categories.nodes.apiName eq "cars")

?q=(suggestedTaxonomies.categories.id eq "B9F568DC43C54803AC76012783FA5101")
text, reference, number, decimal, boolean, datetime.Equals operator (eq) matches the exact value supplied in the query. This operator is not applicable to multivalued data types. The value provided with this operator is not case-sensitive except for standard fields. This operator considers even special characters in the value.
ne?q=(name ne "John")text, reference, number, decimal, boolean, datetime.Not Equals operator (ne) matches items that do not match the exact value supplied in the query. This operator is not applicable to multivalued data types. The value provided with this operator is not case-sensitive except for standard fields. This operator considers even special characters in the value.
co?q=(type eq "Employee" AND name co "john alex")

?q=(type eq "Car" AND fields.features co "manual")

?q=(taxonomies.categories.name co "red")

?q=(taxonomies.categories.nodes.name co "car")
text, reference, number, decimal, datetime, largetextContains operator (co) matches every word given in the criteria. The words are formed by splitting the value by special characters. It gives the results that have at least one of the words (in this example, john or alex or both). This operator does not consider special characters in the value while searching. This operator does not perform a search on stop words. Refer to Apache Lucene documentation to know more about stop words.

This operator is applicable to text, largetext in case of single-valued attributes, whereas for multivalued attributes, it is applicable to text, reference, number, decimal, datetime, largetext. To understand the possible datetime formats, refer to the Supported date/datetime formats (24Hrs) table below. The value provided with this operator is not case-sensitive.
nc?q=(name nc "john alex")text, reference, number, decimal, datetime, largetextNot Contains operator (nc) matches items that would not match a co operator with the same criteria. This operator is not applicable to multivalued data types.
sw?q=(type eq "Employee" AND name sw "Joh")

?q=(type eq "Employee" AND fields.city sw "Los")

?q=(taxonomies.categories.name sw "cat")

?q=(taxonomies.categories.nodes.name sw "red")
textStarts With operator (sw) matches only the initial character values given in the field condition. This operator is not applicable to multivalued data types. The value provided with this operator is not case-sensitive.
ge?q=(type eq "Employee" AND fields.age ge "40")

?q=(type eq "DigitalAsset" AND updatedDate ge "20171026")
number, decimal, datetimeGreater than or equal to operator (ge) matches only numeric and datetime values. To understand the possible datetime formats, refer to the Supported date/datetime formats (24Hrs) table below. This operator is not applicable to multivalued data types.
le?q=(type eq "Employee" AND fields.weight le "60.6")number, decimal, datetimeLess than or equal to operator (le) matches only numeric and datetime values. To understand the possible datetime formats, refer to the Supported date/datetime formats (24Hrs) table below. This operator is not applicable to multivalued data types.
gt?q=(type eq "Employee" AND fields.age gt "20")number, decimal, datetimeGreater than operator (gt) matches only numeric and datetime values. To understand the possible datetime formats, refer to the Supported date/datetime formats (24Hrs) table below. To understand the possible datetime formats, refer to the Supported date/datetime formats (24Hrs) table below. This operator is not applicable to multivalued data types.
lt?q=(type eq "Employee" AND fields.age lt "20")

?q=(type eq "Employee" AND createdDate lt "1994/09/26T16:23:45.208")
number, decimal, datetimeLess than operator (lt) matches only numeric and datetime values. To understand the possible datetime formats, please refer to the section: Supported date/datetime formats (24Hrs). This operator is not applicable to multivalued data types.
mt?q=(type eq "Car" AND fields.review mt "petrol 20KMPL")

?q=(type eq "Employee" AND name mt "Jo?n")

?q=(type eq "Employee" AND name mt "Jo*")

?q=(type eq "Employee" AND fields.role mt "senior*")
text, largetextPhrase query or proximity search (matches) operator (mt) enables you to find words that are within a specific distance to one another. Results are sorted by best match. It is useful for searching content items when values given in the criteria "petrol 20kmpl" need to discover actual content that may contain "petrol fuel mileage runs 20KMPL in the speed way".

Matches operator also can use a wildcard within the given value and supports both single-character and multiple-character wildcard searches within a single value. Use ? for a single-character wildcard and * for multiple characters. Both "John" and "Joan" can be searched by "Jo?n" for a single character and "Jo*" for multiple characters.

This operator is applicable to both single-valued and multivalued data types. This operator does not perform a search on stop words. Refer to Apache Lucene documentation to know more about stop words. The value provided with this operator is not case-sensitive. For matching exact phrases enclose search terms in double quotes. Enclosing double quotes will be treated as part of the search term in all other contexts.
sm?q=(type eq "Employee" And fields.city sm "Rome")text, largetextSimilarity query operator. This operator allows searching for values that sound like specified criteria - also called fuzzy search, which uses by default a maximum of two edits to match the result. "Rome" is similar to "Dome". This operator is applicable to both single-valued and multivalued data types. The value provided with this operator is not case-sensitive.
AND?q=(type eq "Employee" AND name eq "John" AND fields.age ge "40")-NA-AND operator, can be used to put an AND condition between multiple query conditions. This takes precedence over OR.
ORtype eq "Employee" AND name eq "John" OR fields.age ge "40"-NA-OR operator can be used to put an OR condition between multiple query conditions.
( )?q=(type eq "Employee" AND (name eq "John" AND fields.age ge "40"))

?q=(type eq "Employee" AND ( (name eq "John" AND fields.age ge "40") OR fields.weight ge 60))
-NA-Parenthesis, enclosing operator to group the conditions in the criteria. This takes highest precedence, followed by AND, and then by OR.


Additional Notes
Type specific queryThis query always uses only the eq operator. eq works with case-sensitive type name. Multitype query is supported, such as q=(type eq "Employee" OR type eq "Address"), however, it will be query across types.
Example:
q=(type eq "Employee" OR type eq "DigitalAsset") is supported because of single type search.
Date queryDate query is a special type of query because of various date formats associated with it. All the datetime values in the query are assumed to be in the UTC (timezone) only, unless the offset is added in ISO 8901 format. The query results will always be in UTC timezone format for all datetime fields. Fields with the datatype datetime should use the operators ge, gt, le, lt for range query and use eq for an equals match.

Example:
Query Products by manufactureDate (datetime) field using the ge operator.
https://{cecsdomain}/content/management/api/v1.1/items?q=(type eq "Product" AND fields.manufactureDate ge "1989-03-26"). The given date format is YYYY-MM-DD.

Explore more date/datetime specific query examples in the Examples section and also to understand the accepted date/datetime formats in the section below (supported date/datetime formats).
Decimal values Decimal number query is supported up to 3 digits after decimal points, and the rest of the digits after 3 will be ignored. https://{cecsdomain}/content/management/api/v1.1/items?q=(type eq "Product" AND fields.price ge 425.3214), will result in all the products where price is greater than or equal to 425.321.
Large text datatype queryFields with the datatype largetext are not stored, so the query result cannot return its value. But the field value can be used in a query condition.
Generic query searchGeneric query search is a default search query, which can be used when the user can search by only value without using any field name or operators. Internally generic search uses the co operator. This query does not support wildcard characters. This search does not perform search on stop words. Refer to Apache Lucene documentation to know more about stop words.
Example:
?q=(type eq "Employee")&fields=all&default=John. This will return the search results for the Employee type where the value John matches to field name , description or any user-defined fields.
Example:
?q=(type eq "Article")&default=skating. This will return the search results for Article type where the value skating matches to fields name, description or any user-defined fields.
ID searchSearch query using id attribute.
Example:
?q=(type eq "Employee" AND id eq "COREAF29AC6ACA9644F9836E36C7B558F316"). The value of id belongs to the item being queried itself, here the id of type Employee.
It is possible to include multiple item ids in the query expression
Example:
?q=(type eq "Employee" AND (id eq "COREAF29AC6ACA9644F9836E36C7B558F316" OR id eq "COREAF29AC6ACA9644F9836E36C7B558F987")).
Category searchSearch items categorized with given category id, category name, category apiName, category node id, category node name or category node apiName attributes.
Example:
?q=(taxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489")
The value of taxonomies.categories.id belongs to the category assigned to items being queried. It is possible to include multiple category ids or names in the query expression.
Example:
?q=(taxonomies.categories.name co "cars" OR taxonomies.categories.name sw "red")
Example:
?q=(taxonomies.categories.apiName eq "All-furnitures")
The value of taxonomies.categories.apiName belongs to the category assigned to items being queried. It is possible to include multiple category apiName values in the query expression.
Example:
?q=(taxonomies.categories.nodes.id eq "9E1A79EE600C4C4BB727FE3E39E95489")
The value of taxonomies.categories.nodes.id belongs to any node of categories assigned to items being queried. It is possible to include multiple category node ids or node names in the query expression.
Example:
?q=(taxonomies.categories.nodes.name co "cars" OR taxonomies.categories.nodes.name sw "red")
Example:
?q=(taxonomies.categories.nodes.apiName eq "All-furnitures" OR taxonomies.categories.nodes.apiName eq "all-accessories")
The value of taxonomies.categories.nodes.apiName belongs to any node of categories assigned to items being queried. It is possible to include multiple category node apiName values in the query expression.
Suggested Category searchSearch items that could be categorized into a given category with category id, rejected status and language. Only one category id can be used for filtering at a time. repositoryId is mandatory when filtering on suggestedTaxonomy. Default status is NOT rejected. When no language is specified items from all languages are returned.

Example:
?q=(repositoryId eq "86E125F3D78B409EBF61737636599FE1" AND suggestedTaxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489")
Lists all the items from all languages that are suggested for the given category id for the given repository and not rejected.
Example:
?q=(repositoryId eq "86E125F3D78B409EBF61737636599FE1" AND suggestedTaxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489" AND suggestedTaxonomies.categories.isRejected eq "false")
Lists all the items from all languages that are suggested for the given category id for the given repository and not rejected.
Example:
?q=(repositoryId eq "86E125F3D78B409EBF61737636599FE1" AND suggestedTaxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489" AND suggestedTaxonomies.categories.isRejected eq "false" AND language co "en-US")
Lists all the items from the given language that are suggested for the given category id for the given repository.
Example:
?q=(repositoryId eq "86E125F3D78B409EBF61737636599FE1" AND suggestedTaxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489" AND suggestedTaxonomies.categories.isRejected eq "true" AND language co "en-US")
Lists all the items from the given language that are previously rejected for the given category id for the given repository.
Reference field searchSearch query using reference attribute.
Example:
?q=(type eq "Employee" AND fields.department eq "COREAF29AC6ACA9644F9836E36C7B558F412").
The value of department belongs to the id of an item of type Department.


Supported date/datetime formats (24Hrs)
FormatExample
YYYY-MM-DD1989-03-26
YYYY/MM/DD1989/03/26
DD-MM-YYYY26-03-1989
DD/MM/YYYY26/03/1989
YYYY-MM-DD''T''hh:mm:ss1989-03-26T18:32:38
YYYY/MM/DD''T''hh:mm:ss1989/03/26T18:32:38
DD-MM-YYYY''T''hh:mm:ss26-03-1989T18:32:38
DD/MM/YYYY''T''hh:mm:ss26/03/1989T18:32:38
YYYY-MM-DD''T''hh:mm:ss.SSS1989-03-26T18:32:38.840
YYYY/MM/DD''T''hh:mm:ss.SSS1989/03/26T18:32:38.840
DD-MM-YYYY''T''hh:mm:ss.SSS26-03-1989T18:32:38.840
DD/MM/YYYY''T''hh:mm:ss.SSS26/03/1989T18:32:38.840
YYYYMMDD19890326
YYYYMMDDhhmmss19890326183238
YYYYMMDDhhmmssSSS19880326183238840
YYYY-MM-DD''T''hh:mm:ss.SSS+/-HH:mm1989-03-26T18:32:38.840+05:30
YYYY-MM-DD''T''hh:mm:ss+/-HH:mm1989-03-26T18:32:38+05:30
.

Request

Query Parameters
  • This parameter accepts channelToken of a channel and is used to control the returned results. The result will contain only items, targeted to the channel that the specified channelToken belongs to. This can also be achieved by specifying the channels (standard field of an item) contains query condition (channels co "{channelId}") as one of the query conditions in the q query parameter. This is an optional parameter and by default returns all the results.
  • Default search query expression, that matches values of the items across all fields.
  • This parameter is used to control the returned fields in each item in the result. This parameter accepts a comma-separated list of field names or all. These fields will be returned for each items in the result. All the field name are case-sensitive, and users must provide the correct field name in the query. All the user-defined field names should be provided with prefix fields and followed by period (.). When fields is specified as all (case-insensitive), all the standard fields are returned in case of query across types and in case of type specific query, all standard and user fields are returned. This parameter is optional in the query, and by default the result shows only standard fields name, description. The standard fields id, type are always returned irrespective of any field asked. Any incorrect or invalid field name given in the query will throw an error.

    Example: This returns standard fields name, user fields state and country of type Address in the search results.
    https://{cecsdomain}/content/management/api/v1.1/items?q=type eq "Address"&fields=fields.state,fields.country

    Example: This returns all the attributes for a specific type used in the search results.
    https://{cecsdomain}/content/management/api/v1.1/items?q=type eq "Address"&fields=all

    Example: This returns standard fields name, createdBy in the search results for all items across all the types.
    https://{cecsdomain}/content/management/api/v1.1/items?fields=name,createdBy

    Example: This returns all the standard fields in the search results for all items across all the types.
    https://{cecsdomain}/content/management/api/v1.1/items?fields=all
    Default Value: name,description,repositoryId,slug,language,translatable,createdDate,updatedDate
  • This parameter accepts a non negative integer and is used to control the size of the result. If offset+limit > 10000, then we treat limit as 10000-offset and gives results.
    Default Value: 100
  • This parameter accepts a non negative integer less than 10000 and is used to control the start index of the result.
    Default Value: 0
  • The orderBy parameter is used to control the order (ascending/descending) of queried items.
    This parameter is optional in the query and by default the results are sorted in the descending order of updatedDate when default parameter is empty. When default parameter has value(s), the results are sorted by the relevance of tags of the items to the default values.

    This parameter accepts featured() or field name separated by a colon (:) ,for which the user wants to sort the results and sort order. Multiple sort orders are separated by semicolon (;).
    format : orderBy={fieldName1}:{asc/desc};{fieldName2}:{asc/desc} (*Note : asc stands for ascending and desc for descending. asc and desc are always in lower case.)
    In a type-specific query, field names can be either standard fields (name, createdDate, updatedDate) or user-defined fields (single-valued data types (number, decimal, datetime). But in case of a query across types, only name, createdDate and updatedDate (Standard fields) are allowed. All the user-defined field names should be provided with prefix fields and followed by a period (.). While filtering on suggestedTaxonomies the default sort order will by relevance of the suggestion to the item.

    The sort order is optional, and by default it is descending. Any incorrect or invalid field name given in the query will be ignored. When featured() is given and default parameter has value(s), the results are sorted by the relevance of tags of the items to the default values

    Example : orderBy=name:asc
    Returns all the items in the ascending order of name.
    Example : orderBy=updateDate:asc
    Returns all the items in the ascending order of updateDate.
    Example : orderBy=fields.age:desc
    Returns all the items in the descending order of age.
    Example : orderBy=fields.age
    Returns all the items in the ascending order of age.
    Example : default=apples&orderBy=featured()
    Returns all the items sorted by the relevance of tags of the items to the apples
  • This parameter accepts a query expression condition that matches the field values. Many such query conditions can be joined using AND/OR operators and grouped with parentheses. The value of query condition follows the format of {fieldName} {operator} "{fieldValue}". In case of query across type the field names are limited to standard fields (id, type, name, description, slug, translatable, language, createdBy, createdDate, updatedBy, updatedDate, repositoryId, status, channels, collections, tags, isPublished, languageIsMaster, taxonomies). However in case of type specific query the field names are limited to standard fields and user defined fields (except fields of largeText data type). The only values allowed in the operator are eq (Equals), co (Contains), sw (Startswith), ge (Greater than or equals to), le (Less than or equals to), gt (Greater than), lt (Less than), mt (Matches), sm (Similar).
    Example:
    https://{cecsdomain}/content/management/api/v1.1/items?q=(name eq "John")
    Example:
    https://{cecsdomain}/content/management/api/v1.1/items?q=(type eq "Employee" AND name eq "John")
    Example:
    https://{cecsdomain}/content/management/api/v1.1/items?q=(type eq "Employee" AND ((name eq "John" AND field.age ge "40") OR fields.weight gt "70"))
    Example:
    https://{cecsdomain}/content/management/api/v1.1/items?q=(taxonomies.categories.id eq "9E1A79EE600C4C4BB727FE3E39E95489" OR (taxonomies.categories.name co "cat" AND taxonomies.categories.name co "red"))
    Example:
    https://{cecsdomain}/content/management/api/v1.1/items?q=(taxonomies.categories.nodes.id eq "9E1A79EE600C4C4BB727FE3E39E95489" OR taxonomies.categories.nodes.name co "cars")
  • This parameter accepts id of a repository and is used to control the returned results. The result will contain only items belonging to the specified repository. This can also be achieved by specifying the repositoryId (standard field of an item) equals query condition (repositoryId eq "{repositoryId}") as one of the query conditions in the q query parameter. This is an optional parameter and by default returns results from all the repositories.
  • This parameter accepts a boolean flag. If specified as true, then the returned result must include the total result count.
    Default Value: false
Back to Top

Response

Supported Media Types

200 Response

OK.
Body ()
Root Schema : SearchItems
Type: object
Search Items
Show Source
Nested Schema : items
Type: array
Singular resources contained in the collection.
Show Source
Nested Schema : Item
Type: object
Item
Show Source
Nested Schema : ItemSubResourceListTaxonomyInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListChannelId
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListCollectionId
Type: object
Item SubResource.
Show Source
Nested Schema : date
Type: object
date
Show Source
Nested Schema : fields
Type: object
Read Only: true
Additional Properties Allowed
Show Source
User-defined fields data. Map. All the user-defined fields required in the type definition must be provided under this property in PUT and POST request.
Nested Schema : ItemSubResourceListPublishInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceRelationships
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListSuggestedTaxonomyInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListTag
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListVariationsInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListVersionInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListWorkflowInfo
Type: object
Item SubResource.
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : TaxonomyInfo
Type: object
TaxonomyInfo
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : ChannelId
Type: object
ChannelId
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : CollectionId
Type: object
CollectionId
Show Source
Nested Schema : additionalProperties
Type: object
Nested Schema : data
Type: array
Show Source
Nested Schema : PublishInfo
Type: object
PublishInfo
Show Source
Nested Schema : Relationships
Type: object
Relationships
Show Source
Nested Schema : referencedBy
Type: array
Referenced by ids
Show Source
Nested Schema : references
Type: array
Reference ids
Show Source
Nested Schema : References
Type: object
References
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : SuggestedTaxonomyInfo
Type: object
SuggestedTaxonomyInfo
Show Source
Nested Schema : categories
Type: array
Categories in the Suggested Taxonomy the item belongs to.
Show Source
Nested Schema : ItemSuggestedCategoryInfo
Type: object
Show Source
Nested Schema : nodes
Type: array
Nodes in the category assigned to the item.
Show Source
Nested Schema : CategoryNodeBean
Type: object
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : Tag
Type: object
Tag.
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : VariationsInfo
Type: object
Variations Info.
Show Source
Nested Schema : items
Type: array
Content item variations.
Show Source
Nested Schema : Language
Type: object
LanguageItem
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : VersionInfo
Type: object
VersionInfo
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : WorkflowInfo
Type: object
WorkflowInfo.
Show Source

304 Response

Not modified.

400 Response

Bad request.

403 Response

Forbidden.

404 Response

Not found.

500 Response

Internal server error.
Back to Top

Examples

The following example shows details of all the items present by submission of a GET request using cURL.

curl -X GET -H 'Accept: application/json' 'https://host:port/content/management/api/v1.1/items

Example 1:

This lists all items by expanding all fields in the result.

/content/management/api/v1.1/items?fields=all

Response Body

 {
        "hasMore": true,
        "offset": 0,
        "count": 2,
        "limit": 2,
        "items": [
          {
            "translatable": false,
            "updatedBy": "cecusername",
            "publishInfo": {
              "data": [
                {
                  "version": "1",
                  "channel": "CCF8A7D0CD55E2F67DEA60735B0A7F9DF2673661B226",
                  "publishedBy": "cecusername",
                  "publishedDate": {
                    "value": "2018-11-21T11:28:00.354Z",
                    "timezone": "UTC"
                  }
                },
                {
                  "version": "1",
                  "channel": "CC1A40C0A9E74905B811D6208787B1D375C2E407C6D8",
                  "publishedBy": "cecusername",
                  "publishedDate": {
                    "value": "2018-11-21T11:33:56.385Z",
                    "timezone": "UTC"
                  }
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/CONTCA13C93924F9417091A6676EF598AD88/publishInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "isPublished": true,
            "versionInfo": {
              "data": [
                {
                  "latestVersion": "1",
                  "publishedVersion": "1"
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/CONTCA13C93924F9417091A6676EF598AD88/versionInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "description": "Image1 desc",
            "updatedDate": {
              "value": "2018-11-21T11:27:53.000Z",
              "timezone": "UTC"
            },
            "type": "DigitalAsset",
            "version": "1",
            "createdDate": {
              "value": "2018-11-21T11:27:53.000Z",
              "timezone": "UTC"
            },
            "channels": {
              "data": [
                {
                  "id": "CC1A40C0A9E74905B811D6208787B1D375C2E407C6D8"
                },
                {
                  "id": "CCF8A7D0CD55E2F67DEA60735B0A7F9DF2673661B226"
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/CONTCA13C93924F9417091A6676EF598AD88/channels",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "createdBy": "cecusername",
            "collections": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/CONTCA13C93924F9417091A6676EF598AD88/collections",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "name": "Image1.jpg",
            "repositoryId": "F34C5CC35EBE0CF859522674141C545B1B9C88797260",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/items/CONTCA13C93924F9417091A6676EF598AD88",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "CONTCA13C93924F9417091A6676EF598AD88",
            "slug": null
          },
          {
            "translatable": false,
            "updatedBy": "cecusername",
            "publishInfo": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/publishInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "isPublished": false,
            "versionInfo": {
              "data": [
                {
                  "latestVersion": "0.001"
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/versionInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "description": "Item1 description",
            "language": "en-US",
            "updatedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            },
            "type": "Type1",
            "version": "0.001",
            "createdDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            },
            "channels": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/channels",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "taxonomies": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/taxonomies",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "createdBy": "cecusername",
            "collections": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/collections",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "name": "Item1",
            "repositoryId": "FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "slug": "1481786064272-type1-item1"
          }
        ]
      }

Example 2:

This lists all items whose repositoryId is FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49 and displays repositoryId in results.

/content/management/api/v1.1/items?q=type eq \"Type1\"

Response Body

{
        "hasMore": true,
        "offset": 0,
        "count": 1,
        "limit": 1,
        "items": [
          {
            "name": "Item1",
            "description": "Item1 description",
            "repositoryId": "FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49",
            "links": [
              {
                "href": "https://host:port/content/management/api/v1.1/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "type": "Type1"
          }
        ]
      }
    },
    {
      "method": "GET",
      "url": "/content/management/api/v1.1/items?q=(type eq \"Product\" AND fields.manufactureDate ge \"1989-03-26\")",
      "description": "Lists all items of type: product and whose custom field manufactureDate is greater than 26th March,1989",
      "responseCode":200
    },
    {
      "method": "GET",
      "url": "/content/management/api/v1.1/items?q=type eq \"Employee\" AND (name eq \"John\" OR fields.age ge \"40\")",
      "description": "Lists all items of type: Employee and either name equals John or custom field age is greater than 40",
      "responseCode":200
    },
    {
      "method": "GET",
      "url": "/content/management/api/v1.1/items?q=(type eq \"Employee\" AND fields.role mt \"senior\")",
      "description": "Lists all items of type: Employee and custom field role matches with senior",
      "responseCode":200
    },
    {
      "method": "GET",
      "url": "/content/management/api/v1.1/items?q=(type eq \"Car\" AND fields.features co \"manual\")",
      "description": "Lists all items of type: Car and custom field features contains manual",
      "responseCode":200
    }
  ]
}
    
Back to Top