# Get all items

- Operation ID: `getItemsByBusinessProfileid`
- HTTP method: `GET`
- Path: `/catalogs/items`
- [Human-readable API reference](https://hub.synerise.com/api-reference/asset-management#operation/getItemsByBusinessProfileid)

## Self-contained OpenAPI method

The fenced document below contains this method's documentation and all of its local references. It is self-contained; no category or master specification fetch is required.

```yaml
openapi: 3.0.0
info:
  title: Synerise Public API
  version: 1.9.5
paths:
  /catalogs/items:
    get:
      tags:
        - Catalogs
      summary: Get all items
      description: |
        Retrieve all items from all catalogs in the Workspace.

        ---

        **API consumers:** <a href="/api-reference/authorization?tag=Authorization&amp;operationId=userLogin" target="_blank" rel="noopener">Synerise User</a>, <a href="/api-reference/authorization?tag=Authorization&amp;operationId=profileLogin" target="_blank" rel="noopener">Workspace (Business Profile)</a>

        **API key permission required:** `CATALOGS_CATALOG_READ`

        **User role permission required:** `assets_catalogs: read`
      operationId: getItemsByBusinessProfileid
      security:
        - JWT: []
        - BasicAuth: []
      parameters:
        - in: query
          name: offset
          description: The offset for the search. For example, if your `limit` is 10 and you want to retrieve the third page of items, set the offset to 20. Items with indexes 20 to 29 are returned (the first item on the first page has the index 0).
          required: false
          schema:
            type: integer
        - in: query
          name: limit
          description: "The maximum number of items to include in the response. `offset` must be defined. Default: 100"
          required: false
          schema:
            type: integer
      responses:
        "200":
          description: A list of items in the Workspace
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: array
                    description: Details of the items
                    items:
                      type: object
                      description: Details of the item
                      properties:
                        bag:
                          type: object
                          description: Metadata of the catalog that includes the entry
                          properties:
                            id:
                              type: integer
                              format: int64
                              description: Catalog ID
                            name:
                              type: string
                              description: Catalog name
                            businessProfileId:
                              type: integer
                              description: ID of the Business Profile that contains this catalog
                            author:
                              type: string
                              description: ID of the catalog's creator
                            lastModified:
                              type: string
                              format: date-time
                              description: Last modification date
                            creationDate:
                              format: date-time
                              type: string
                              description: Creation date
                            primaryKey:
                              type: object
                              required:
                                - name
                              properties:
                                name:
                                  type: string
                                description:
                                  type: string
                            mappings:
                              type: array
                              items:
                                type: object
                                required:
                                  - bpActionParamKey
                                  - bagId
                                  - itemId
                                  - action
                                  - paramKey
                                  - enrichmentFields
                                properties:
                                  bpActionParamKey:
                                    type: string
                                  bagId:
                                    type: integer
                                    format: int64
                                  itemId:
                                    type: integer
                                    format: int64
                                  action:
                                    type: string
                                  paramKey:
                                    type: string
                                  enrichmentFields:
                                    type: array
                                    items:
                                      type: string
                        itemKey:
                          type: string
                          description: They unique value of the item key (for example, an SKU) that was used to upload this entry. This is the `key` query parameter used in [this endpoint](#operation/getItemByKey).
                        id:
                          type: integer
                          format: int64
                          description: ID of the entry. This is the `itemId` used in [this endpoint](#operation/getItem).
                        value:
                          type: string
                          description: Contents of the entry
                          example: '{"Name":"John","Surname":"Doe"}'
                        creationDate:
                          type: string
                          description: Creation date of the entry
                        lastModified:
                          type: string
                          description: Last modified date of the entry
                  metaData:
                    type: object
                    description: This object holds the metadata of the response.
                    properties:
                      totalCount:
                        type: integer
                        description: The total number of matching values (key-value pairs; array items; objects) in the database
                      requestTime:
                        type: string
                        description: The processing time of the request
                        example: 0.11 [s]
        "401":
          description: "Unauthorized: token missing/expired/invalid; invalid API key; etc."
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: integer
                    description: Status code
                  error:
                    type: string
                    description: Error summary
                  message:
                    type: string
                    description: Error message
                  timestamp:
                    type: string
                    description: Time when the error occurred
        "403":
          description: "Forbidden: insufficient permissions; wrong consumer scope"
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: integer
                    description: Status code
                  error:
                    type: string
                    description: Error summary
                  message:
                    type: string
                    description: Error message
                  timestamp:
                    type: string
                    description: Time when the error occurred
      x-snr-doc-urls:
        - /api-reference/data-management#tag/Catalogs/operation/getItemsByBusinessProfileid
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: |-
            curl --request GET \
              --url 'https://api.synerise.com/catalogs/items?offset=SOME_INTEGER_VALUE&limit=SOME_INTEGER_VALUE' \
              --header 'Authorization: Basic REPLACE_BASIC_AUTH'
        - lang: Python
          label: Python
          source: |-
            import http.client

            conn = http.client.HTTPSConnection("api.synerise.com")

            headers = { 'Authorization': "Basic REPLACE_BASIC_AUTH" }

            conn.request("GET", "/catalogs/items?offset=SOME_INTEGER_VALUE&limit=SOME_INTEGER_VALUE", headers=headers)

            res = conn.getresponse()
            data = res.read()

            print(data.decode("utf-8"))
        - lang: JavaScript
          label: JavaScript
          source: |-
            const data = null;

            const xhr = new XMLHttpRequest();
            xhr.withCredentials = true;

            xhr.addEventListener("readystatechange", function () {
              if (this.readyState === this.DONE) {
                console.log(this.responseText);
              }
            });

            xhr.open("GET", "https://api.synerise.com/catalogs/items?offset=SOME_INTEGER_VALUE&limit=SOME_INTEGER_VALUE");
            xhr.setRequestHeader("Authorization", "Basic REPLACE_BASIC_AUTH");

            xhr.send(data);
        - lang: Node.js
          label: Node.js
          source: |-
            const http = require("https");

            const options = {
              "method": "GET",
              "hostname": "api.synerise.com",
              "port": null,
              "path": "/catalogs/items?offset=SOME_INTEGER_VALUE&limit=SOME_INTEGER_VALUE",
              "headers": {
                "Authorization": "Basic REPLACE_BASIC_AUTH"
              }
            };

            const req = http.request(options, function (res) {
              const chunks = [];

              res.on("data", function (chunk) {
                chunks.push(chunk);
              });

              res.on("end", function () {
                const body = Buffer.concat(chunks);
                console.log(body.toString());
              });
            });

            req.end();
        - lang: PHP
          label: PHP
          source: |-
            <?php

            $request = new HttpRequest();
            $request->setUrl('https://api.synerise.com/catalogs/items');
            $request->setMethod(HTTP_METH_GET);

            $request->setQueryData([
              'offset' => 'SOME_INTEGER_VALUE',
              'limit' => 'SOME_INTEGER_VALUE'
            ]);

            $request->setHeaders([
              'Authorization' => 'Basic REPLACE_BASIC_AUTH'
            ]);

            try {
              $response = $request->send();

              echo $response->getBody();
            } catch (HttpException $ex) {
              echo $ex;
            }
        - lang: Java
          label: Java
          source: |-
            HttpResponse<String> response = Unirest.get("https://api.synerise.com/catalogs/items?offset=SOME_INTEGER_VALUE&limit=SOME_INTEGER_VALUE")
              .header("Authorization", "Basic REPLACE_BASIC_AUTH")
              .asString();
servers:
  - url: https://api.synerise.com
    description: Microsoft Azure EU
  - url: https://api.azu.synerise.com
    description: Microsoft Azure USA
  - url: https://api.geb.synerise.com
    description: Google Cloud Platform
tags:
  - name: Catalogs
components:
  securitySchemes:
    JWT:
      type: http
      scheme: bearer
      description: |
        Synerise uses [JSON Web Token (JWT)](https://jwt.io/) as the authorization method.

        The token is generated by the *auth/login* endpoints.

        You need to include it in the `Authorization` header of your requests, with a `Bearer` prefix.


        By default, the token is valid for **one week** (see [workspace settings](https://hub.synerise.com/docs/settings/tool/iam-for-apps/general/#jwt-lifetime)).  
        You can request a refreshed key for the session by using the *auth/refresh* endpoint **before** the current token expires.


        You can verify your JWT signature by using the [public key](https://api.synerise.com/v4/public.pem).


        See Developer Guides on JWT API authentication for:
        - [profiles](https://hub.synerise.com/developers/api/api-authorization/client-login/);
        - [workspaces](https://hub.synerise.com/developers/api/api-authorization/workspace-login/#api-authentication-with-jwt);
        - [users](https://hub.synerise.com/developers/api/api-authorization/user-login/).
    BasicAuth:
      type: http
      scheme: basic
      description: |
        Basic authentication with login (workspace GUID) and password (workspace API key) encoded with Base64 and sent in the `Authorization` header. **Must be enabled in the settings of the API key**.

        <span style="color:red">This is less secure than JWTs.</span> Limit the API key permissions to only those that you need. Consider API key rotation and other security measures.

        You can still use JWTs from the same API key when basic authentication is enabled.

        For details, see ["Workspace authentication"](https://hub.synerise.com/jwt-or-basic/#basic-api-authentication-with-api-keys).
```
