# List Products

GET https://services.leadconnectorhq.com/products/

The "List Products" API allows to retrieve a paginated list of products. Customize your results by filtering products based on name or paginate through the list using the provided query parameters. This endpoint provides a straightforward way to explore and retrieve product information.

## Authentication

Send `Authorization: Bearer <token>` using any one of:

- **Sub-Account token: OAuth access token or Private Integration Token.** Scopes: `products.readonly`
- **Agency token: OAuth access token or Private Integration Token.** Scopes: `products.readonly`

## Parameters

### Header Parameters

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `Version` | string | Yes | API Version |

### Query Parameters

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `limit` | number | No | The maximum number of items to be included in a single page of results |
| `offset` | number | No | The starting index of the page, indicating the position from which the results should be retrieved. |
| `locationId` | string | Yes | LocationId is the id of the sub-account |
| `search` | string | No | The name of the product for searching. |
| `collectionIds` | string | No | Filter by product category Ids. Supports comma separated values |
| `collectionSlug` | string | No | The slug value of the collection by which the collection would be searched |
| `expand` | array | No | Name of an entity whose data has to be fetched along with product. Possible entities are tax, stripe and paypal. If not mentioned, only ID will be returned in case of taxes |
| `productIds` | array | No | List of product ids to be fetched. |
| `storeId` | string | No | fetch and project products based on the storeId |
| `includedInStore` | boolean | No | Separate products by which are included in the store and which are not |
| `availableInStore` | boolean | No | If the product is included in the online store |
| `sortOrder` | string | No | The order of sort which should be applied for the date |

## OpenAPI Specification

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "HighLevel API",
    "version": "v3"
  },
  "servers": [
    {
      "url": "https://services.leadconnectorhq.com"
    }
  ],
  "paths": {
    "/products/": {
      "get": {
        "summary": "List Products",
        "operationId": "listProducts",
        "description": "The \"List Products\" API allows to retrieve a paginated list of products. Customize your results by filtering products based on name or paginate through the list using the provided query parameters. This endpoint provides a straightforward way to explore and retrieve product information.",
        "parameters": [
          {
            "name": "Version",
            "in": "header",
            "description": "API Version",
            "required": true,
            "schema": {
              "type": "string",
              "enum": [
                "v3"
              ]
            }
          },
          {
            "name": "limit",
            "required": false,
            "in": "query",
            "description": "The maximum number of items to be included in a single page of results",
            "schema": {
              "default": 0,
              "example": 20,
              "type": "number"
            }
          },
          {
            "name": "offset",
            "required": false,
            "in": "query",
            "description": "The starting index of the page, indicating the position from which the results should be retrieved.",
            "schema": {
              "default": 0,
              "example": 0,
              "type": "number"
            }
          },
          {
            "name": "locationId",
            "required": true,
            "in": "query",
            "description": "LocationId is the id of the sub-account",
            "schema": {
              "example": "3SwdhCu3svxI8AKsPJt6",
              "type": "string"
            }
          },
          {
            "name": "search",
            "required": false,
            "in": "query",
            "description": "The name of the product for searching.",
            "schema": {
              "example": "Awesome product",
              "type": "string"
            }
          },
          {
            "name": "collectionIds",
            "required": false,
            "in": "query",
            "description": "Filter by product category Ids. Supports comma separated values",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "collectionSlug",
            "required": false,
            "in": "query",
            "description": "The slug value of the collection by which the collection would be searched",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "expand",
            "required": false,
            "in": "query",
            "description": "Name of an entity whose data has to be fetched along with product. Possible entities are tax, stripe and paypal. If not mentioned, only ID will be returned in case of taxes",
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          {
            "name": "productIds",
            "required": false,
            "in": "query",
            "description": "List of product ids to be fetched.",
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          {
            "name": "storeId",
            "required": false,
            "in": "query",
            "description": "fetch and project products based on the storeId",
            "schema": {
              "example": "3SwdhCu3svxI8AKsPJt6",
              "type": "string"
            }
          },
          {
            "name": "includedInStore",
            "required": false,
            "in": "query",
            "description": "Separate products by which are included in the store and which are not",
            "schema": {
              "example": true,
              "type": "boolean"
            }
          },
          {
            "name": "availableInStore",
            "required": false,
            "in": "query",
            "description": "If the product is included in the online store",
            "schema": {
              "example": true,
              "type": "boolean"
            }
          },
          {
            "name": "sortOrder",
            "required": false,
            "in": "query",
            "description": "The order of sort which should be applied for the date",
            "schema": {
              "example": "desc",
              "enum": [
                "asc",
                "desc"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ListProductsResponseDto"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BadRequestDTO"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnauthorizedDTO"
                }
              }
            }
          },
          "422": {
            "description": "Unprocessable Entity",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnprocessableDTO"
                }
              }
            }
          }
        },
        "security": [
          {
            "Location-Access": [
              "products.readonly"
            ]
          },
          {
            "Agency-Access": [
              "products.readonly"
            ]
          }
        ]
      }
    }
  },
  "components": {
    "securitySchemes": {
      "bearer": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account (OR) Private Integration Token of Sub-Account.",
        "type": "http"
      },
      "Location-Access": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account (OR) Private Integration Token of Sub-Account.",
        "type": "http"
      },
      "Location-Access-Only": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Sub-Account.",
        "type": "http"
      },
      "Agency-Access": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Agency (OR) Private Integration Token of Agency.",
        "type": "http"
      },
      "Agency-Access-Only": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "name": "Authorization",
        "in": "header",
        "description": "Use the Access Token generated with user type as Agency.",
        "type": "http"
      }
    },
    "schemas": {
      "ListProductsResponseDto": {
        "type": "object",
        "properties": {
          "products": {
            "description": "An array of products",
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "_id": {
                  "type": "string",
                  "description": "The unique identifier for the product.",
                  "example": "655b33a82209e60b6adb87a5"
                },
                "description": {
                  "type": "string",
                  "description": "product description",
                  "example": "This is a really awesome product"
                },
                "variants": {
                  "description": "An array of variants for the product.",
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "id": {
                        "type": "string",
                        "description": "A unique identifier for the variant.",
                        "example": "38s63qmxfr4"
                      },
                      "name": {
                        "type": "string",
                        "description": "The name of the variant.",
                        "example": "Size"
                      },
                      "options": {
                        "description": "An array of options for the variant.",
                        "type": "array",
                        "items": {
                          "type": "object",
                          "properties": {
                            "id": {
                              "type": "string",
                              "description": "The unique identifier for the option.",
                              "example": "h4z7u0im2q8"
                            },
                            "name": {
                              "type": "string",
                              "description": "The name of the option.",
                              "example": "XL"
                            }
                          },
                          "required": [
                            "id",
                            "name"
                          ],
                          "title": "ProductVariantOptionDto"
                        }
                      }
                    },
                    "required": [
                      "id",
                      "name",
                      "options"
                    ],
                    "title": "ProductVariantDto"
                  }
                },
                "locationId": {
                  "type": "string",
                  "description": "The unique identifier for the location.",
                  "example": "3SwdhCsvxI8Au3KsPJt6"
                },
                "name": {
                  "type": "string",
                  "description": "The name of the product.",
                  "example": "Awesome Product"
                },
                "productType": {
                  "type": "string",
                  "description": "The type of the product (e.g., PHYSICAL).",
                  "example": "PHYSICAL"
                },
                "availableInStore": {
                  "type": "boolean",
                  "description": "Indicates whether the product is available in-store.",
                  "example": true
                },
                "createdAt": {
                  "format": "date-time",
                  "type": "string",
                  "description": "The creation timestamp of the product.",
                  "example": "2023-11-20T10:23:36.515Z"
                },
                "updatedAt": {
                  "format": "date-time",
                  "type": "string",
                  "description": "The last update timestamp of the product.",
                  "example": "2024-01-23T09:57:04.846Z"
                },
                "statementDescriptor": {
                  "type": "string",
                  "description": "The statement descriptor for the product.",
                  "example": "abcde"
                },
                "image": {
                  "type": "string",
                  "description": "The URL for the product image.",
                  "example": "https://storage.googleapis.com/ghl-test/3SwdhCsvxI8Au3KsPJt6/media/65af8d5df88bdb4b1022ee90.png"
                },
                "collectionIds": {
                  "description": "An array of category Ids for the product",
                  "example": [
                    "65d71377c326ea78e1c47df5",
                    "65d71377c326ea78e1c47d34"
                  ],
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                },
                "isTaxesEnabled": {
                  "type": "boolean",
                  "description": "The field indicates whether taxes are enabled for the product or not.",
                  "example": true,
                  "default": false
                },
                "taxes": {
                  "description": "An array of ids of Taxes attached to the Product. If the expand query includes tax, the taxes will be of type `ProductTaxDto`. Please refer to the `ProductTaxDto` for additional details.",
                  "example": [
                    "654492a4e6bef380114de15a"
                  ],
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                },
                "automaticTaxCategoryId": {
                  "type": "string",
                  "description": "Tax category ID for Automatic taxes calculation.",
                  "example": "65d71377c326ea78e1c47df5"
                },
                "label": {
                  "description": "The Product label details",
                  "allOf": [
                    {
                      "type": "object",
                      "properties": {
                        "title": {
                          "type": "string",
                          "description": "The content for the product label.",
                          "example": "Featured"
                        },
                        "startDate": {
                          "type": "string",
                          "description": "Start date in YYYY-MM-DDTHH:mm:ssZ format",
                          "example": "2024-06-26T05:43:35.000Z"
                        },
                        "endDate": {
                          "type": "string",
                          "description": "Start date in YYYY-MM-DDTHH:mm:ssZ format",
                          "example": "2024-06-30T05:43:39.000Z"
                        }
                      },
                      "required": [
                        "title"
                      ],
                      "title": "ProductLabelDto"
                    }
                  ]
                },
                "slug": {
                  "type": "string",
                  "description": "The slug of the product by which the product will be navigated",
                  "example": "washing-machine"
                }
              },
              "required": [
                "_id",
                "locationId",
                "name",
                "productType",
                "createdAt",
                "updatedAt"
              ],
              "title": "DefaultProductResponseDto"
            }
          },
          "total": {
            "description": "list products status",
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "total": {
                  "type": "number",
                  "description": "Total number of products",
                  "example": 20
                }
              },
              "required": [
                "total"
              ],
              "title": "ListProductsStats"
            }
          }
        },
        "required": [
          "products",
          "total"
        ],
        "title": "ListProductsResponseDto"
      },
      "BadRequestDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 400
          },
          "message": {
            "type": "string",
            "example": "Bad Request"
          }
        },
        "title": "BadRequestDTO"
      },
      "UnauthorizedDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 401
          },
          "message": {
            "type": "string",
            "example": "Invalid token: access token is invalid"
          },
          "error": {
            "type": "string",
            "example": "Unauthorized"
          }
        },
        "title": "UnauthorizedDTO"
      },
      "UnprocessableDTO": {
        "type": "object",
        "properties": {
          "statusCode": {
            "type": "number",
            "example": 422
          },
          "message": {
            "example": [
              "Unprocessable Entity"
            ],
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "error": {
            "type": "string",
            "example": "Unprocessable Entity"
          }
        },
        "title": "UnprocessableDTO"
      }
    }
  }
}
```

## HighLevel SDK Examples

**Node.js** (`@gohighlevel/api-client`)

```javascript
import HighLevel from '@gohighlevel/api-client';

const ghl = new HighLevel({
  privateIntegrationToken: '<PRIVATE_INTEGRATION_TOKEN>'
});

const response = await ghl.products.listProducts({ locationId: '<LOCATIONID>' });
console.log(response);
```

**Python** (`gohighlevel-api-client`)

```python
from highlevel import HighLevel

client = HighLevel(
    private_integration_token='<PRIVATE_INTEGRATION_TOKEN>'
)

response = await client.products.list_products(locationId='<LOCATIONID>')
print(response)
```

**PHP** (`gohighlevel/api-client`)

```php
<?php
require_once 'vendor/autoload.php';

use HighLevel\HighLevel;
use HighLevel\HighLevelConfig;

$config = new HighLevelConfig([
    'privateIntegrationToken' => '<PRIVATE_INTEGRATION_TOKEN>'
]);
$ghl = new HighLevel($config);

$response = $ghl->products->listProducts(['locationId' => '<LOCATIONID>']);
echo json_encode($response, JSON_PRETTY_PRINT);
```

## Code Examples

**cURL**

```bash
curl -L -X GET 'https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>' \
  -H 'Authorization: Bearer <TOKEN>' \
  -H 'Version: v3'
```

**Node.js**

```javascript
const options = {
  method: 'GET',
  headers: {
    Authorization: 'Bearer <TOKEN>',
    Version: 'v3'
  }
};

try {
  const response = await fetch('https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>', options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**Python**

```python
import requests

url = "https://services.leadconnectorhq.com/products/"

headers = {
    "Authorization": "Bearer <TOKEN>",
    "Version": "v3"
}

params = {
    "locationId": "<LOCATIONID>"
}

response = requests.get(url, params=params, headers=headers)
print(response.json())
```

**PHP**

```php
<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => 'https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer <TOKEN>',
    'Version: v3',
  ],
]);

$response = curl_exec($curl);
curl_close($curl);
echo $response;
```

**Java**

```java
HttpResponse<String> response = Unirest
  .get("https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>")
  .header("Authorization", "Bearer <TOKEN>")
  .header("Version", "v3")
  .asString();
```

**Go**

```go
package main

import (
  "fmt"
  "net/http"
  "io"
)

func main() {
  url := "https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <TOKEN>")
  req.Header.Add("Version", "v3")

  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := io.ReadAll(res.Body)
  fmt.Println(string(body))
}
```

**Ruby**

```ruby
require 'uri'
require 'net/http'

url = URI("https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer <TOKEN>"
request["Version"] = "v3"

response = http.request(request)
puts response.read_body
```

**PowerShell**

```powershell
$headers = @{
  "Authorization" = "Bearer <TOKEN>"
  "Version" = "v3"
}

$response = Invoke-RestMethod -Uri 'https://services.leadconnectorhq.com/products/?locationId=<LOCATIONID>' -Method 'GET' -Headers $headers
$response | ConvertTo-Json
```