1. REST API for Content Management
  2. Tasks
  3. Archive Items Search

Query Archived Items

get

/content/management/api/v1.1/archive/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/archive/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/archive/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. Searching on a reference field of type any is not supported. Sorting by second level fields is not supported.
    For example:
    /management/api/v1.1/archive/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 depending on how it is specified may either treated as a global query or a query across multiple types. A query that references multiple types using brackets ( ) is treated as a global query and query conditions are limited to standard fields (id, type, name, description, typeCategory, slug, translatable, language, createdBy, createdDate, updatedBy, updatedDate, repositoryId, channels, collections, status, tags, isPublished, languageIsMaster, taxonomies, isRestoreScheduled, archivedBy, archivedDate) only.
    For example:
    /management/api/v1.1/archive/items?q=(name eq "John" and (type eq "t1" or type eq "t2")) or /management/api/v1.1/archive/items?q=(description co "users" and (type eq "t1" or type eq "t2")).

    A query that references multiple types using braces { } is treated as a generic query across types with the ability to reference standard and user defined fields.
    For example:
    /management/api/v1.1/archive/items?q=name eq "John" and {type eq "t1" and fields.ud1 eq "ud1val"} or {type eq "t2" and fields.ud2 eq "ud2val"}
    Characteristics of the brace style query across types.
    1. A cross-type search is specified by enclosing type predicates in the query (q) parameter in curly braces { }.
    2. Only one type may be specified in a matching set of braces.
    3. Nested braces are not allowed.
    4. Braces and brackets may be combined.
    5. Query predicates specified outside braces behave like they were specified using brackets.
    6. Examples -
      • {type eq "t1" and repositoryid eq "r1"}
      • {type eq "t1" and repositoryid eq "r1" and fields.ud1 eq "ud1"} - "ud1" has to be a field on type "t1". Query validation will fail if that is not the case.
      • {type eq "t1" and repositoryid eq "r1"} and {type eq "t2" and repositoryid eq "r1"} - This is a valid query but would return zero results.
      • {type eq "t1" and fields.ud1 eq "ud1"} or {type eq "t2" and fields.ud2 eq "ud2"} - "ud1" has to be a field on type "t1" and "ud2" has to be a field on type "t2"
      • {type eq "t2" and fields.ud2 eq "ud2"} or type eq "t1" and fields.ud1 eq "ud1" ??? Bracket style search that resolves to type "t1" and brace style search that resolves to type "t2" and is valid if "ud1" is a field on "t1" and "ud2" is a field on "t2".

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/archive/items?default="coffee"
/management/api/v1.1/archive/items?q=(type eq "Employee")&default="senior"

In either form, while querying using standard fields, name, description, type, typeCategory, 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, archivedDate as a datetime data type (single valued), translatable, isPublished, languageIsMaster, isRestoreScheduled 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=(type eq "File" and fileextension eq "docx")

?q=(taxonomies.id eq "773CDF9B048E429D856F3CA2A14A9CEA")

?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")

?q=(colorTags.tagName eq "#ff0000")		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.

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.
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 can use a wildcard (? or *) to match multiple characters within the given value. This operator is applicable to both single-valued and multivalued data types. This operator does not perform a search on 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/archive/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/archive/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.
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")).
Taxonomy searchSearch items with given taxonomy id.
Example:
?q=(taxonomies.id eq "773CDF9B048E429D856F3CA2A14A9CEA")
The value of taxonomies.id belongs to the taxonomy assigned to items being queried. It is possible to include multiple taxonomy ids in the query expression.
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.
Scheduled Restore status searchSearch items by scheduled for restore status.

Example:
?q=isRestoreScheduled eq "true"
Lists all the archived items that are scheduled for restore.
Example:
?q=isRestoreScheduled eq "false"
Lists all the archived items that are not scheduled for restore.
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.
Query matching text in binary fileSearching in binary file text (typed searches for digital assets only). Searching in the digital assets' binary file's text is supported using metadata.extractedText parameter in the search query within a type or across specific types. Supported operators are co, nc and mt.
Example:
?q=(type eq "File" AND metadata.extractedText co "Employee")
?q=((type eq "cdt1" or type eq "cdt2") AND metadata.extractedText mt "installed")


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
.
Notes: message in response indicates that this is possibly an abnormal search result set. For e.g., a database based search in the event of backend search service being unavailable.Query matching text in any field and the binary fileSearching in the fields and binary file text (typed searches for content or digital assets). Searching in the fields and binary file's text is supported using anyField parameter in the search query within a type or across specific types. Supported operators are co, nc and mt.
Example:
?q=(type eq "contentType1" AND anyField co "Employee")
?q=({type eq "contentType1" AND anyField mt "installed"} OR {type eq "cdt1" AND anyField mt "installed"})

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.
  • Default search query operator. This parameter is optional. It accepts 'or' and 'and' operators. If not provided, defaultOperator would be considered as 'or'.
  • This parameter is used to allow user to get permissions on each item. Accepts permissions only. Cannot be combined with returnMaster=true. And limit must not be greater than 100.
  • This parameter is used to control the returned fields in each archived 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 names 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.In the context of a brace style cross-type query, type specific fields may be specified using syntax name,{typename1:fields.userdefinedfieldname1,fields.userdefinedfieldname2},{typename2:fields.userdefinedfieldname1}. In the preceding example, all items of type typename1 will have fields - name, userdefinedfieldname1 and userdefinedfieldname2, while all items of type typename2 will have fields - name, userdefinedfieldname1. If the cross-type query does not resolve to types referenced in the typed fields clause(s), an error will be thrown.
    It is also possible to return existing metadata for assets specifying fields as metadata or metadata.exif. Currently, only EXIF metadata is available for newly uploaded images.

    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/archive/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/archive/items?q=type eq "Address"&fields=all

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

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

    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/archive/items?fields=all

    Example: This returns the available metadata in the search results for all items across all the types.
    https://{cecsdomain}/content/management/api/v1.1/archive/items?fields=metadata

    Example: This returns the available EXIF metadata in the search results for all items across all the types.
    https://{cecsdomain}/content/management/api/v1.1/archive/items?fields=metadata.exif
    Default Value: name,description,repositoryId,slug,language,translatable,createdDate,updatedDate,archivedBy,archivedDate,isRestoreScheduled,fileExtension
  • This parameter accepts a non negative integer and is used to control the size of the result. The maximum value allowed for limit is 500. If offset+limit > 10000, then we treat limit as 10000-offset and give 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 search score 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). All the user-defined field names should be provided with prefix fields and followed by a period (.). In the context of a cross-type search, this parameter can also have a typed section and takes the form {typename1:fields.userdefinedfieldname1:asc|desc};{typename2:fields.userdefinedfieldname1:asc|desc}. The order by parameter only supports one order by field per set of matching braces. While filtering on suggestedTaxonomies the default sort order will by relevance of the suggestion to the item.

    OrderBy parameter also supports sorting by a two level field. If there is a two level sort field, then it can be the only sort field in the OrderBy parameter.
    OrderBy parameter also supports sorting by taxonomy root categories and sub-categories of a root category. The additional sorting parameters are
    taxonomies.shortName["short name of taxonomy"]:{asc/desc}; taxonomies.categories.nodes.name["short name of taxonomy"|"taxonomy name","category1","category2","category3"] where category1, category2,category3, etc.
    are sub-categories of a given taxonomy "taxonomy name".
    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
    Example : orderBy=fields.blogauthor.authorage
    Returns all the items in the ascending order of age of the author referred by referenced field "blogauthor".
    Example : orderBy=fields.blogauthor.fields.authorage&twolvl_v1_1=true
    Returns all the items in the ascending order of age of the author referred by referenced field "blogauthor".
    Example : orderBy=taxonomies.shortName["loc"];taxonomies.categories.nodes.name["loc"|"Location","emea","china","industry"];
    taxonomies.categories.nodes.name["loc"|"Location","americas","brazil","industry"]
    Returns all the items in the ascending order of root category of "loc", sub-categories of category having path "/Location/emea/china/industry", sub-categories of category having path "/Location/americas/brazil/industry".
  • 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 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/archive/items?q=(name eq "John")
    Example:
    https://{cecsdomain}/content/management/api/v1.1/archive/items?q=(type eq "Employee" AND name eq "John")
    Example:
    https://{cecsdomain}/content/management/api/v1.1/archive/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/archive/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/archive/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.
  • Specifying this parameter indicates that scroll behavior is expected from the search api. Scrolling is the recommended method for retrieving large result sets. Scrolling is not available when returnMaster is enabled. hasMore will always return false when scrolling is enabled. offset parameter value, if specified, will be ignored on scroll requests. limit parameter value will be interpreted in the context of scroll and be fixed for a scroll session. Subsequent changes to limit will be ignored for the scroll session. A limit that results in too large a response will result in a 413 (Payload Too Large) response status.
    Default Value: false
  • This parameter is used to specify the scroll id. scrollTTL and the original value of the q parameter are always required with requests that use a scrollId to get consistent results. Note that the requirement to always include the q parameter in subsequent scroll requests is currently not validated against previous requests and changes to the parameter within the same scroll session are ignored.
  • scrollTTL (in milliseconds - default and maximum value 30000 ms) specifies the period of inactivity allowed between the current and next scroll request. All responses to search with scroll include a scrollId. Subsequent scroll requests must include the scrollId returned from the previous response since the scrollId returned could change across requests. Since all scroll requests are stateless, scrollTTL is always expected. Value of scrollTTL does not have to be the same across requests. The original search query (q) is also expected with each subsequent scroll request. An invalid or expired scrollId will result in a 400 (Bad Request) response status.
    Default Value: 30000
  • This parameter accepts a boolean flag. If specified as true, then the returned result must include the total result count.
    Default Value: false
  • This parameter does not need a value and when used indicates that the two level search api uses (i) fields.refname.fieldname to search on system fields such as name, description, etc of the referred type; and (ii) fields.refname.fields.userfieldname to search on user defined fields of the referred type. When this parameter is not used, two level search behaves in compatibility mode and only supports searches like fields.reftype.fieldname. Furthermore, when fieldname is the same as a system defined field name, two level search behaves the same as fields.reftype.fields.fieldname.
Back to Top

Response

Supported Media Types

200 Response

OK.
Body ()
Root Schema : SearchArchivedItems
Type: object
Search Archived Items
Show Source
Nested Schema : aggregationResults
Type: array
Aggregation results.
Show Source
Nested Schema : items
Type: array
Singular resources contained in the collection.
Show Source
Nested Schema : pinned
Type: array
Pinned items. Shows items pinned at the top of search list
Show Source
Nested Schema : AggregationResult
Type: object
Show Source
Nested Schema : ArchivedItem
Type: object
Archived Item
Show Source
Nested Schema : date
Type: object
date
Show Source
Nested Schema : ItemSubResourceListChangesInfo
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 : ItemSubResourceConnectorFileInfo
Type: object
Item SubResource.
Show Source
Nested Schema : User
Type: object
User object
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 : ItemSubResourceLockInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemMetadataInfo
Type: object
ItemMetadataInfo
Show Source
Nested Schema : ItemSubResourceListAction
Type: object
Item SubResource.
Show Source
Nested Schema : ItemSubResourceListPublishInfo
Type: object
Item SubResource.
Show Source
Nested Schema : ItemReferenceInfo
Type: object
ItemReferenceInfo
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 : ItemSubResourceListTaxonomyInfo
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 : VideoBean
Type: object
VideoBean
Show Source
Nested Schema : WorkflowField
Type: object
All mapped workflow fields
Show Source
Nested Schema : ItemSubResourceListWorkflowInfo
Type: object
Item SubResource.
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : ChangesInfo
Type: object
ChangesInfo
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 : ConnectorFileInfo
Type: object
ConnectorFileInfo
Show Source
Nested Schema : additionalProperties
Type: object
Nested Schema : LockInfo
Type: object
LockInfo
Show Source
Nested Schema : EXIFMetadata
Type: object
EXIF Metadata
Show Source
Nested Schema : VideoTranscriptMetadata
Type: object
Video Transcription Metadata
Show Source
Nested Schema : aggregationResults
Type: array
Aggregation results.
Show Source
Nested Schema : items
Type: array
Singular resources contained in the collection.
Show Source
Nested Schema : pinned
Type: array
Pinned items. Shows items pinned at the top of search list
Show Source
Nested Schema : ItemExtractedExifBean
Type: object
ItemExtractedExifBean
Show Source
Nested Schema : aggregationResults
Type: array
Aggregation results.
Show Source
Nested Schema : items
Type: array
Singular resources contained in the collection.
Show Source
Nested Schema : pinned
Type: array
Pinned items. Shows items pinned at the top of search list
Show Source
Nested Schema : Videotranscript
Type: object
Video transcript
Show Source
Nested Schema : data
Type: array
Show Source
Nested Schema : Action
Type: object
Action
Show Source
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 : Siteplanreference
Type: object
Site plan reference
Show Source
Nested Schema : referencedBySites
Type: array
Referenced by sites
Show Source
Nested Schema : references
Type: array
Reference ids
Show Source
Nested Schema : References
Type: object
References
Show Source
Nested Schema : ReferencedBySites
Type: object
ReferencedBySites
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 : TaxonomyInfo
Type: object
TaxonomyInfo
Show Source
Nested Schema : categories
Type: array
Categories in the Taxonomy the item belongs to.
Show Source
Nested Schema : ItemCategoryInfo
Type: object
Show Source
Nested Schema : nodes
Type: array
Nodes in the category assigned to the item.
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 : PlaybackBean
Type: object
PlaybackBean
Show Source
Nested Schema : ProcessingBean
Type: object
ProcessingBean
Show Source
  • Read Only: true
    The progress of the background process. The value of this field will be one of PENDING, SUCCEEDED or FAILED.
Nested Schema : StripBean
Type: object
StripBean
Show Source
Nested Schema : AdaptiveStreamsBean
Type: object
AdaptiveStreamsBean
Show Source
Nested Schema : StripFrameBean
Type: object
StripFrameBean
Show Source
Nested Schema : aggregationResults
Type: array
Aggregation results.
Show Source
Nested Schema : items
Type: array
Singular resources contained in the collection.
Show Source
Nested Schema : pinned
Type: array
Pinned items. Shows items pinned at the top of search list
Show Source
Nested Schema : WorkflowInfo
Type: object
WorkflowInfo.
Show Source
Nested Schema : data
Type: array
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 how to Archive Items search by submitting a GET request using cURL.

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

Example 1

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

This lists all archived items.

Response Body

{
        "hasMore": true,
        "offset": 0,
        "count": 2,
        "limit": 2,
        "items": [
          {
            "name": "Image1.jpg",
            "fileExtension": "jpg",
            "description": "Image1 description",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/items/CONTCA13C93924F9417091A6676EF598AD88",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "CONTCA13C93924F9417091A6676EF598AD88",
            "type": "DigitalAsset",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          },
          {
            "name": "Item1",
            "fileExtension": "contentItem",
            "description": "Item1 description",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "type": "Type1",
            "isRestoreScheduled": true,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          }
        ]
      }

Example 2 

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

This lists all archived items by expanding all fields in results.

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/archive/items/CONTCA13C93924F9417091A6676EF598AD88/publishInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "isPublished": false,
            "versionInfo": {
              "data": [
                {
                  "latestVersion": "1",
                  "publishedVersion": "1"
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/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",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            },
            "typeCategory": "DigitalAssetType",
            "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/archive/items/CONTCA13C93924F9417091A6676EF598AD88/channels",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "createdBy": "cecusername",
            "collections": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/items/CONTCA13C93924F9417091A6676EF598AD88/collections",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "name": "Image1.jpg",
            "fileExtension": "jpg",
            "repositoryId": "F34C5CC35EBE0CF859522674141C545B1B9C88797260",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/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/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/publishInfo",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "isPublished": false,
            "versionInfo": {
              "data": [
                {
                  "latestVersion": "0.1"
                }
              ],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/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",
            "typeCategory": "ContentType",
            "version": "0.1",
            "createdDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            },
            "channels": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/channels",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "taxonomies": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/taxonomies",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "createdBy": "cecusername",
            "collections": {
              "data": [],
              "links": [
                {
                  "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786/collections",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "name": "Item1",
            "fileExtension": "contentItem",
            "repositoryId": "FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "slug": "1481786064272-type1-item1",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          }
        ]
      }

Example 3 

/content/management/api/v1.1/archive/items?q=type eq \"Type1\""
This lists all archive items of type: Type1.

Response Body 

{
        "hasMore": true,
        "offset": 0,
        "count": 1,
        "limit": 1,
        "items": [
          {
            "name": "Item1",
            "fileExtension": "contentItem",
            "description": "Item1 description",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "type": "Type1",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          }
        ]
      }

Example 4 

/content/management/api/v1.1/archive/items?q=repositoryId eq \"FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49\"&fields=name,repositoryId

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

Response Body 

{
        "hasMore": true,
        "offset": 0,
        "count": 1,
        "limit": 1,
        "items": [
          {
            "name": "Item1",
            "description": "Item1 description",
            "repositoryId": "FF3F3EA7B9AA02DAB862BD32428A3162608D14D20E49",
            "links": [
              {
                "href": "https://<hostname>/content/management/api/v1.1/archive/items/COREFFFEC388CFD044D8A34D2F8C46EA5786",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "COREFFFEC388CFD044D8A34D2F8C46EA5786",
            "type": "Type1",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          }
        ]
      }

Example 5 

/content/management/api/v1.1/archive/items?default=horizontal&fields=id,metadata,type

This lists the id, metadata and type of all archive items that have the keyword `horizontal` as a field value.

Response Body 

{
        "hasMore": true,
        "offset": 0,
        "count": 1,
        "limit": 1,
        "items": [
          {
            "metadata": {
              "exif": {
                "items": [
                  {
                    "rawId": "37378",
                    "handle": "Aperture",
                    "rawValue": "169/100",
                    "value": "1.8"
                  },
                  {
                    "rawId": "274",
                    "handle": "Orientation",
                    "rawValue": "1",
                    "value": "Horizontal (normal)"
                  }
                ],
                "links": [
                  {
                    "href": "http://<hostname>/content/management/api/v1.1/archive/items/CONTBD1B71657BF14BC2ABB8D763E44975E8/metadata/exif",
                    "rel": "self",
                    "method": "GET",
                    "mediaType": "application/json"
                  }
                ]
              },
              "links": [
                {
                  "href": "http://<hostname>/content/management/api/v1.1/archive/items/CONTBD1B71657BF14BC2ABB8D763E44975E8/metadata",
                  "rel": "self",
                  "method": "GET",
                  "mediaType": "application/json"
                }
              ]
            },
            "links": [
              {
                "href": "http://<hostname>/content/management/api/v1.1/archive/items/CONTBD1B71657BF14BC2ABB8D763E44975E8",
                "rel": "self",
                "method": "GET",
                "mediaType": "application/json"
              }
            ],
            "id": "CONTBD1B71657BF14BC2ABB8D763E44975E8",
            "type": "Image",
            "isRestoreScheduled": false,
            "archivedBy": "cecusername",
            "archivedDate": {
              "value": "2018-11-16T06:19:15.641Z",
              "timezone": "UTC"
            }
          }
        ],
        "links": [
          {
            "href": "http://<hostname>/content/management/api/v1.1/archive/items?fields=id,metadata,type&default=horizontal",
            "rel": "self",
            "method": "GET",
            "mediaType": "application/json"
          },
          {
            "href": "http://<hostname>/content/management/api/v1.1/archive/items?fields=id,metadata,type&default=horizontal",
            "rel": "canonical",
            "method": "GET",
            "mediaType": "application/json"
          },
          {
            "href": "http://<hostname>/content/management/api/v1.1/archive/items?fields=id,metadata,type&offset=0&default=horizontal",
            "rel": "first",
            "method": "GET",
            "mediaType": "application/json"
          },
          {
            "href": "http://<hostname>/content/management/api/v1.1/archive/items?fields=id,metadata,type&offset=0&default=horizontal",
            "rel": "last",
            "method": "GET",
            "mediaType": "application/json"
          }
        ]
      }
Back to Top