Beta Version

banner
icon sign

Welcome to Pixyle's API Documentation! This is your guide to easily adding our advanced visual AI technology to your digital assets. Whether you're improving your online store or refining your digital content, Pixyle's API gives developers like you the power to tap into the benefits of AI with ease.

Introduction

To get started with integrating Pixyle's AI-driven e-commerce solutions, simply contact us today to get your user credentials and begin transforming your digital journey.

Overview of Products and Solutions
Pixyle AI provides a variety of tools to enhance your online presence:

Product Tagging

Bounding Box Detection:
Gain granular insights into fashion images with Pixyle.ai's bounding box detection feature. Our solution accurately identifies and locates fashion objects within images, providing precise coordinates for each object. Whether it's detecting clothing items, accessories, or footwear, the bounding box detection enables detailed analysis and annotation of fashion imagery.

Automatic Tagging:
Effortlessly categorize and classify fashion objects in images with Pixyle.ai's automatic tagging solution. By leveraging machine learning algorithms, our system assigns relevant tags and attributes to each fashion item detected in the image. From colors and patterns to clothing types and styles, automatic tagging streamlines catalog management and enhances product discovery for retailers and e-commerce platforms.

Label Recognition:
Identify and extract valuable information from fashion labels with Pixyle.ai's label recognition capability. Our solution analyzes images to recognize and interpret the labels attached to clothing items, accessories, and other fashion products. By extracting tags and metadata from labels, businesses can enrich product data, improve search relevance, and enhance customer engagement.

Text Generation

Title Generation:
Craft compelling and descriptive titles for fashion products with Pixyle.ai's title generation feature. Our solution analyzes the visual attributes and characteristics of fashion objects in images to generate informative and engaging titles automatically. From brand names and product types to key features and styles, title generation streamlines content creation and enhances product presentation for online retailers and fashion platforms.

Description Generation:
Create compelling and informative descriptions for fashion products with Pixyle.ai's description generation solution. Our system analyzes the visual content of fashion images to generate detailed and engaging descriptions that highlight key features, materials, and styling cues. From sizing information to care instructions, description generation enhances product listings and improves the overall shopping experience for consumers.

Image Moderation

Automatic Rescale:
Resize images seamlessly to fit different screens and devices, ensuring a consistent and user-friendly presentation. contact us

ShotType Detection:
Identify different types of shots in images, making it easier to analyze and edit content for better storytelling. contact us

Background Removal:
Easily remove backgrounds from images to create clean and professional visuals that highlight the subject. contact us

Similar Products

Similar Recommendations:
Offer personalized product suggestions based on visual similarities, boosting engagement and sales. contact us

Visual Search:
Let users search for products using images, making their shopping experience more intuitive and enjoyable. contact us

With Pixyle's API and these innovative features, you have the tools to create exceptional digital experiences that captivate and delight your audience. Start exploring today and leverage the full potential of visual AI in your digital catalogs.

Glossary

Fashion item:
Fashion item is any article or accessory of clothing, footwear, or other wearable items.

Primary Product:
Primary Product is the main fashion item that is recognized by Pixyle.ai models. This is the product that is being sold in the image(s), and it's the main item for which data should be generated.

Primary Image:
Primary image is the one of the product images that is detected as the best image representation of the primary product.

Collection:
A collection is a data structure that is used to group multiple products together. Also known as datasets.

Collection processing:
Involves bulk processing of a collection of products. The system accepts a file containing multiple products, processing each one sequentially upon upload. Results for each product are available as soon as its processing is completed.

Real-time processing:
Is processing of one image or one product at a time and the results are immediately available for further processing.

Taxonomy:
Represents a hierarchical classification system and it consists of a structured set of tags that are used to classify images based on their visual characteristics, content, or attributes. The taxonomy is relevant only for Automatic Tagging and Label Recognition and it represents in which structure the generated data will be returned.

Tag:
Refers to a label or keyword assigned to images or items for the purpose of categorization, classification, or organizing data. A tag can be a category or an attribute.

Confidence Score:
Is a numerical value that represents the level of certainty or confidence in the accuracy or reliability of a prediction made by the model.

Verification Process:
Represents the Human-in-the-loop (HITL) concept. It is a process in which the human is reviewing the AI generated data and approves it or corrects it.
When a verification process of a product is done, means that the data is reviewed by human and it’s available for further usage. Wherever possible, we recommend having a human review outputs prior to their implementation in practice.

Integration manual

How to connect with the environment

To connect with Pixyle API environment and use our services you will need credentials. To receive credentials please contact us. You will then receive an email from Pixyle with information of your new account and option to set up a password in within next 24 hours. Once you set your account, you can use those credentials to authenticate either to:

Pixyle API
Or Pixyle Dashboard. You can read how to use Pixyle AI services via Pixyle Dashboard here.

There are no specific system requirements or dependencies needed for successful integration with the Pixyle API.

Base URL

Base URLs:

Authentication API URL:

https://api.pixyle.ai/auth/v1

Integration Resources

Integration Resources:

Integration Sequence Diagram Flow: Details on how the integration process should proceed.

Authentication Endpoints: Includes code samples for authenticating with the Pixyle API.

Error Handling: Explanation of custom errors that may occur during integration.

Main API Endpoints: Includes code samples for accessing the main functionalities of the Pixyle API.

Additional Resources: Further assistance for integration-related questions or issues.

Feel free to contact us if you have any questions or need assistance with the integration process.

Sequence diagram

Authentication Request

Access/Permanent Token

Upload/Create Collection Request

System starts with processing all products with all active features

[If you need to retrieve the data for all products simultaneously]
Wait until processed_products_percentage = 100.0

Patch Update Product Request

Update the generated data & verify a product

Collection Processing (Basic flow)

Real-time processing



Real-time processing

Authentication - OAuth 2.0

Bearer Token

OAuth 2.0 Bearer Token authenticates requests on behalf of your app.

This authentication method requires for you to pass a Bearer Token with your request, which you can generate by using your email and already set-up password. Below you can find obtain/revoke token endpoints.

Here is an example of what a request looks like with a fake Bearer Token:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections/123456' \
--header 'Authorization: Bearer eyJhbG..'

Base URL

The base URL for accessing Pixyle.ai's authentication API is:

https://api.pixyle.ai/auth/v1

Obtain a token

Obtain a token

POST /token


Obtain a token, that you can use as an authorization for the rest of the endpoints. The endpoint allows you to obtain an access or a permanent token, and you can set this by using a flag in the request body.

Headers
None

Parameters
None

Body

Parameters:
None

Body:

email:

(string) The email for the account with which you want to authorize

password:

(string) The password for the account with which you want to authorize. If the account is still not set up with password please refer to the email you receive from us and finalize the set-up using our dashboard

permanent_login:

(boolean) A flag that represents if you want to obtain a permanent token. By default is false.


Body:


Response
Returns a JSON object with the following properties:

access_token:

(string) The access token that you can use to authorize in Pixyle API

expires_in:

(int) Time in seconds, in which the access token will expire. False if permanent_login is true.

Request:

POST
curl --location 'https://api.pixyle.ai/auth/v1/token' \
--header 'Content-Type: application/json' \
--data-raw '{
    "email": "test@email.com",
    "password": "testpassword"
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/auth/v1/token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    'email': 'test@email.com',
    'password': 'testpassword'
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
		'Content-Type': 'application/json',
}

json_data = {
    'email': 'test@email.com',
    'password': 'testpassword',
}

response = requests.post('https://api.pixyle.ai/auth/v1/token', headers=headers, json=json_data)

Response:

POST
{
    "access_token": "eyJhbG...",
    "expires_in": 86400
}

Revoke a token

DELETE /revoke_access


Use this endpoint to revoke and invalidate a token. Once a token is revoked it can’t be used for as an authorization for Pixyle API.

Headers
Authorization Bearer access_token

Parameters
None

Body
None

Response
Upon successful revoke of the token, the endpoint returns a JSON object with a confirmation message:

Headers:
Authorization Bearer access_token

Parameters:
N
‍‍

Body:
None

Response:
Upon successful revoke of the token, the endpoint returns a JSON object with a confirmation message:

msg:

(string) A message that confirms that the token is revoked

Request:

POST
curl --location --request DELETE 'https://api.pixyle.ai/auth/v1/revoke_access' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/auth/v1/revoke_access', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

response = requests.delete('https://api.pixyle.ai/auth/v1/revoke_access', headers=headers)

Request:

POST
{
    "msg": "Access Token Revoked"
}


If you need to update your password, or you forgot your password, feel free to use our dashboard.

Limitations

Mode
Throughput
Simultaneous processing
Collection processing
1/s
10
Real-time processing
2/s
/

Collection Processing Mode

Upload Rate: Users are limited to uploading one collection per second.
Simultaneous Processing: Each user can have a maximum of 10 collections processing simultaneously.

Real-time Processing Mode

Upload Rate: Users are limited to uploading two products per second.

These limitations are designed to ensure efficient use of resources and maintain optimal performance for all users.
If you have specific use cases that require higher throughput, please contact our support team at support@pixyle.ai.

Errors

Check out a handy list of possible errors neatly organized by API. We've made sure to explain each error in a friendly way to make your experience smooth and hassle-free.

If you need to update your password, or you forgot your password, feel free to use our dashboard.

Errors:

Check out a handy list of possible errors neatly organized by API. We've made sure to explain each error in a friendly way to make your experience smooth and hassle-free.

Error codes
Error
Description
400
Bad Request
The request sent contains unexpected or invalid values.Double-check the information you provided in the request to ensure it follows the correct format and includes valid data.
401
Missing Authorization Header
Your request is missing valid authentication credentials or the provided token is incorrect or expired.Ensure you have provided the correct authentication details (token) and that the token is not expired. Obtain a new token if needed.
401
Invalid/Expired Token, Can't Complete Authorization
Your request is missing valid authentication credentials or the provided token is incorrect or expired.Ensure you have provided the correct authentication details (token) and that the token is not expired. Obtain a new token if needed.
401
User not found
Your request is missing valid authentication credentials or the provided token is incorrect or expired.Ensure you have provided the correct authentication details (token) and that the token is not expired. Obtain a new token if needed.
404
Page not Found
The URL you provided is invalid or does not exist.Check the URL to make sure it is correct. If you continue to experience issues, please verify the endpoint and try again.
405
Method Not Allowed
The HTTP method used (e.g., POST, GET) is not allowed for this endpoint.Ensure that you are using the correct HTTP method for the specific endpoint. Review the API documentation for the allowed methods.
422
Unprocessable Entity
The request structure is not correct or is missing required elements.Review the request structure and make sure it adheres to the specified format. Ensure that all required fields are included.
429
Too Many Requests
Rate limit exceeded. You have sent too many requests in a short period.Wait for a moment and try again later. If the issue persists, consider optimizing your application to make fewer requests or contact support for assistance.
500
Internal server error
Explanation: Some of our servers might be temporarily unavailable.Action: This is an issue on our end. Please try again later, and if the problem persists, contact our support team.

Authentication API

Error codes
Error
Description
Present
1001
Missing JSON Body in the Request
This error occurs because the server expected your request to include a JSON body, but it appears to be missing. Please ensure you include the required JSON data in your request, following the format specified in the documentation.
API
1002
Unprocessable Entity
Some field is missing or is invalid. Check the 'detail' key in the response for details. Each detail entry includes a 'loc' key, indicating the field in the request which is creating the issue, and a 'msg' key explaining the error associated with that field.
API
1003
Incorrect Email, Try Again Please!
The email address provided in the login attempt is not recognized or does not conform to the expected format.
API; Dashboard
1004
This user did not set up initial password!
The user account is missing an initial password setup, this process involves creating and setting a password for your account. To proceed, please follow the instructions sent to your email for setting up a secure password. This ensures the security of your account.
API; Dashboard
1005
Incorrect Password, Try Again Please!
This error indicates that the password entered is incorrect or does not match the email. Please double-check your password and try again.
API; Dashboard
1006
Current password is invalid
This message means that the password you entered as your current one is not correct. Please double-check and enter the correct old password to proceed with the password change.
API; Dashboard
1007
Passwords do not match
Please make sure the new password and the confirmation match exactly.
API; Dashboard
1008
The password needs to be longer than 8 characters
Please choose a longer password for better security.
API; Dashboard
1009
The password should have at least one lowercase letter
Include at least one small letter in your password for added security.
API; Dashboard
1010
The password should have at least one uppercase letter
Add at least one capital letter to your password for better security.
API; Dashboard
1011
The password should have at least one digit
Make sure to include at least one number in your password for added security.
API; Dashboard

Main API
Collections

Error codes
Error
Description
Present
1100
Missing JSON in the request. Please add a JSON.
This error occurs because the server expected your request to include a JSON body, but it appears to be missing. Please ensure you include the required JSON data in your request, following the format specified in the documentation.
API
1101
Missing the File Part in Request. Please attach a file.
No file uploaded. Please attach a file to your request.
API
1102
Missing 'file' in Request. Please attach the file under the key 'file'.
Missing file key file. Please ensure your request includes the required key associated with the file you intend to upload.
API
1106
Invalid file type. Only CSV and JSON Files are Allowed.
For Upload a Collection:It looks like you uploaded a file with an invalid format (e.g., .txt, .jpeg). Please make sure to upload files in the supported formats: .csv or .json.For Export a Collection:It looks like you want to download the results in an invalid format. Please make sure to export the data in the supported formats: .csv or .json
API; Dashboard
1108
The collection is empty.
The provided collection is empty. The provided JSON or CSV file doesn’t contain any products.
API; Dashboard
1109
The collection is not a list. Unable to parse {file}.
The provided JSON collection should be formatted as a list. Ensure that your data is structured in a list format for successful processing. Check the format here.
API; Dashboard
1110
The objects in the collection are not dictionaries. Unable to parse {file}.
Invalid collection structure. Your collection does not meet the expected format; it contains element(s) that are not in dictionary form.  Ensure that your data is structured in a list of dictionaries for successful processing. Check the format here.
API; Dashboard
1111
Unable to parse {file} .The CSV file has no/invalid header.
The provided CSV file either lacks a header or contains an invalid header format. Please ensure that the CSV file includes a valid header for proper processing. Check the format here.
API; Dashboard
1112
Invalid CSV/JSON file
The file that you uploaded is not valid CSV/JSON file.
API; Dashboard
1116
Collection ID must be greater than 0
The collection ID that you are trying to use is negative integer. Ensure you are using valid collection ID.
API
1117
The collection with the specified ID doesn’t exist or has been deleted.
The collection ID that you are trying to use doesn’t exists for this account. Either the collection was never created or it was deleted.
API
1118
Collection name cannot be blank;Collection name cannot exceed 128 characters; Collection name can only contain alphanumeric characters, hyphens, underscores, dots, and spaces
Please make sure that the new name is not black, doesn’t exceed 128 characters and contains only alphanumeric characters, hyphens, underscores, dots, and spaces.
API

Main API
Products in collections

Error codes
Error
Description
Present
1120
Invalid value for '{field}' for product {i}. Please check the error code for more details.
A mandatory field for one of the products in the collection is either missing or contains an unexpected value. Check the 'detail' key in the response for details. Each detail entry includes a 'loc' key, indicating the invalid field, and a 'msg' key explaining the error associated with that field.The number “i” represents the serial number of product with invalid data in the collection.
API; Dashboard
1122
Unable to download the image
The image URL that you provided for one of the images can’t be downloaded. Check the 'detail' key in the response for details. Each detail entry includes a ‘received’ key that explain what was received as a status code when we tried to download the image from the provided URL.
API; Dashboard
1123
Invalid image file
The content of the image URL was downloaded but it couldn’t be processed as image.
API; Dashboard
1124
Invalid value for a non-mandatory field
The value that is given for one of the non-mandatory fields is not valid. This can include invalid image URL for image_url_2..8, invalid type for the field ‘title’ etc.
API; Dashboard
1130
Not been able to download or open any of the images
All images that are provided for this product can’t be downloaded or open. This means that the system doesn’t have at least one image for this product and it can’t process it. No data will be generated for this product.
API; Dashboard
1131
The product with the specified SKU doesn't exist or has been deleted.
The product SKU that you are trying to use doesn’t exists for this account. Either the product was never created or it was deleted.
API

API OVERVEW

Pixyle.ai offers a powerful API that enables developers to integrate cutting-edge image recognition and capabilities into their applications. Leveraging state-of-the-art machine learning algorithms, Pixyle.ai empowers developers to build advanced image-based solutions for e-commerce, retail, inventory management, and more.

The solutions are accessible through the real-time and the collection processing mode:
• Real-time processing mode - This mode is tailored for handling single products providing instantly processing the request with minimal latency, Its essential for use cases like applications that requires instant rendering of the data that we provide.
• Collection processing mode - This mode is tailored for handling extensive products collections where instant response is not required. This approach is suitable for use cases where the data can be later filtered, manipulated, exported at once or product by product.

Base URL

The base URL for accessing Pixyle.ai's API is:

https://api.pixyle.ai/main/v1

API Endpoints

Real-time Processing

Process a product

POST /products

This endpoint allows you to upload a single product to the Pixyle API and immediately receive a response with the generated data. Each product will be processed with all features that are active for your account. Once the product is processed and response is retrieved you aren’t able to perform any changes on the data or delete the product itself.

We automatically delete the products after 6 months.

If you upload more than one image for the product (image_url_2..8), the system will process all of them and the results will be generated based on all images.

If the ‘category’ field is filled with a category from Pixyle’s taxonomy, the system will localize and focus on that specific fashion item. Please note that at present, our system exclusively supports categories listed in Pixyle’s taxonomy. If you input a category that Pixyle does not support into the 'category' field, the product will still be processed. However, an error will be saved for that product, advising you to review and either add or correct the category accordingly.

The remaining optional fields do not impact the generated data; thus, the decision to include them is entirely at your discretion.

Note that the system doesn’t check for duplicate SKUs in this processing mode, so each successful request will be charged.


Headers
Authorization Bearer access_token

Parameters

This endpoint allows you to get specific product and its result from a processed collection.

Headers:
Authorization Bearer access_token

Parameters:

None

Body
Type: application/json

Required:

product:

(dict) Dict that holds the information for the product that should be processed.

sku:

(string) The SKU of the product

image_url_1:

(string) URL of an image of a product


Optional
(they can be left empty):

image_url_2..8:

(string) URL of an image of a product

category:

(string) Category of a product

title:

(string) A title of a product

description:

(string) A description of a product


Response
Returns a JSON object with the following properties:

Body
None

Response
Returns a JSON object with the following properties:

errors:

(list) A list of error objects associated with the product

sku:

(string) The SKU of the product

result:

(list) A list with result object for each detected fashion item in the images

detection_id:

(int) The unique Pixyle Detection ID for this fashion item

primary_image:

(string) An image from the products list of images which is detected as a primary image of the product

extra_images:

(list) A list of extra images for the product

primary_detection:

(boolean) A boolean flag that indicates if the detected item is the primary product

features:

(list) A list that contains objects for each feature result

feature_name:

(string) The name of the feature that this result is for

feature_result:

An object/list that represents the result of this feature

For "bounding_box":

Contains the top-left (x_min, y_min) and bottom-right (x_max, y_max) corners of the bounding box

x_min:

(float) Represents the minimum value of the x-coordinate in the bounding box

y_min:

(float) Represents the minimum value of the y-coordinate in the bounding box

x_max:

(float) Represents the minimum value of the x-coordinate in the bounding box

y_max:

(float) Represents the minimum value of the y-coordinate in the bounding box

For "automatic_tagging":

Contains an array of objects representing different types of generated tags

tags_type:

(string) Indicates the type of the generated tags

tags:

(list) A list of objects representing individual tags associated with the tags_type

·

value:

(string) Represents generated tag

·

score:

(float) Indicates the confidence score associated with the generated tag

For "label_recognition":

Contains an array of objects representing different types of generated tags

tags_type:

(string) Indicates the type of the generated tags

tags:

(list) A list of objects representing individual tags associated with the tags_type

·

value:

(string) Represents generated tag

·

metadata:

Additional metadata associated with a tag

meta_key:

(string) Represents the key of the metadata

meta_value:

(string) Represents the value of the metadata

For "title_generation", and "description_generation":

Contains an array of objects representing the generated data in different languages.

value:

(string) Represents the generated title/description

language:

(string) Represents the language of the generated title/description

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/products' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "product": {
        "sku": "1",
        "image_url_1": "https://www.pixyle.ai/img.jpg",
        "image_url_2": "https://www.pixyle.ai/img_1.jpg",
        "image_url_3": "https://www.pixyle.ai/img_2.jpg",
        "image_url_4": "https://www.pixyle.ai/img_3.jpg",
        "image_url_5": "https://www.pixyle.ai/img_4.jpg"
    }
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/products', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'product': {
      'sku': '1',
      'image_url_1': 'https://www.pixyle.ai/img.jpg',
      'image_url_2': 'https://www.pixyle.ai/img_1.jpg',
      'image_url_3': 'https://www.pixyle.ai/img_2.jpg',
      'image_url_4': 'https://www.pixyle.ai/img_3.jpg',
      'image_url_5': 'https://www.pixyle.ai/img_4.jpg'
    }
  })
}
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'product': {
        'sku': '1',
        'image_url_1': 'https://www.pixyle.ai/img.jpg',
        'image_url_2': 'https://www.pixyle.ai/img_1.jpg',
        'image_url_3': 'https://www.pixyle.ai/img_2.jpg',
        'image_url_4': 'https://www.pixyle.ai/img_3.jpg',
        'image_url_5': 'https://www.pixyle.ai/img_4.jpg',
    },
}

response = requests.post('https://api.pixyle.ai/main/v1/products', headers=headers, json=json_data)


Response:

POST

{
    "errors": [],
    "sku": "1",
    "result": [
        {
            "detection_id": 1,
            "primary_image": "https://www.pixyle.ai/img.jpg",
            "extra_images": [
                "https://www.pixyle.ai/extra_img_1.jpg",
                "https://www.pixyle.ai/extra_img_2.jpg",
                "https://www.pixyle.ai/extra_img_3.jpg",
                "https://www.pixyle.ai/extra_img_4.jpg"
            ],
            "primary_detection": true,
            "features": [
                {
                    "feature_name": "bounding_box",
                    "feature_result": {
                        "x_max": 1021.45,
                        "x_min": 465.94,
                        "y_max": 1616.13,
                        "y_min": 438.91
                    }
                },
                {
                    "feature_name": "automatic_tagging",
                    "feature_result": [
                        {
                            "tags_type": "category",
                            "tags": [
                                {
                                    "value": "dress",
                                    "score": 0.77948
                                }
                            ],
                            "options": [
                                "blouse",
                                "coat",
                                "skirt",
                                // Additional options
                            ]
                        },
                        {
                            "tags_type": "neckline_type",
                            "tags": [
                                {
                                    "value": "round-neck",
                                    "score": 0.77948
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "sleeve_length",
                            "tags": [
                                {
                                    "value": "short-sleeve",
                                    "score": 0.99961
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "colors",
                            "tags": [
                                {
                                    "value": "bordeaux",
                                    "score": 0.71499
                                },
                                {
                                    "value": "black",
                                    "score": 0.22111
                                }
                            ],
                            "options": [...]
                        },
                        {...}
                    ]
                },
                {
                    "feature_name": "label_recognition",
                    "feature_result": [
                        {
                            "tags_type": "brand",
                            "tags": [
                                {
                                    "value": "Zara",
                                    "metadata": []
                                }
                            ]
                        },
                        {
                            "tags_type": "made_in",
                            "tags": [
                                {
                                    "value": "India",
                                    "metadata": []
                                }
                            ]
                        },
                        {
                            "tags_type": "size",
                            "tags": [
                                {
                                    "value": "8",
                                    "metadata": [
                                        {
                                            "meta_key": "size_type",
                                            "meta_value": "UK"
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            "tags_type": "size",
                            "tags": [
                                {
                                    "value": "4",
                                    "metadata": [
                                        {
                                            "meta_key": "size_type",
                                            "meta_value": "US"
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            "tags_type": "material",
                            "tags": [
                                {
                                    "value": "polyester",
                                    "metadata": [
                                        {
                                            "meta_key": "material_percentage",
                                            "meta_value": "57"
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                },
                {
                    "feature_name": "title_generation",
                    "feature_result": [
                        {
                            "value": "Casual Midi Dress",
                            "language": "English"
                        },
                        {
                            "value": "Robe midi décontractée",
                            "language": "French"
                        }
                    ]
                },
                {
                    "feature_name": "description_generation",
                    "feature_result": [
                        {
                            "value": "Introducing our luxurious lace and silk dress, designed with the sophisticated woman in mind...",
                            "language": "English"
                        },
                        {
                            "value": "Voici notre luxueuse robe en dentelle et soie, conçue pour les femmes sophistiquées...",
                            "language": "French"
                        }
                    ]
                }
            ]
        },
        {
            "detection_id": 2,
            "primary_image": "https://www.pixyle.ai/img.jpg",
            "features": [
                {
                    "feature_name": "bounding_box",
                    "feature_result": {
                        "x_min": 278.05,
                        "y_min": 89.77,
                        "x_max": 299.89,
                        "y_max": 117.08
                    }
                },
                {
                    "feature_name": "automatic_tagging",
                    "feature_result": [
                        {
                            "tags_type": "category",
                            "tags": [
                                {
                                    "value": "accessory",
                                    "score": 0.32
                                }
                            ],
                            "options": [
                                "t-shirt",
                                "polo-shirt",
                                "tank-top",
                                // Additional options
                            ]
                        },
                        {
                            "tags_type": "accessory_type",
                            "tags": [
                                {
                                    "value": "earrings",
                                    "score": 0.976
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "colors",
                            "tags": [
                                {
                                    "value": "silver",
                                    "score": 0.702
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "style",
                            "tags": [
                                {
                                    "value": "business",
                                    "score": 0.753
                                },
                                {
                                    "value": "casual",
                                    "score": 0.453
                                }
                            ],
                            "options": [...]
                        }
                    ]
                }
            ]
        }
    ]
}

Collections Processing

Upload a collection

POST /collections


This endpoint allows you to upload collections of products in either CSV or JSON format.
The uploaded file should contain information about one or multiple products. Please refer to the examples provided below for the appropriate structure of the CSV and JSON files.

• Example CSV file
• Example JSON file

Field
Type
Description
Mandatory
sku
string
SKU of a product
Yes
image_url_1
string
URL of an image of a product
Yes
image_url_2..8
string
URL of an image of a product
No
category
string
Category of a product
No
title
string
A title of a product
No
description
string
A description of a product
No
Any other metadata that you can provide
/
A metadata that won’t be used
No

Please note that all products in the file must have the mandatory fields, otherwise will result in an unsuccessful upload.

If the ‘category’ field is filled with a category from Pixyle’s taxonomy, the system will localize and focus on that specific fashion item. Please note that at present, our system exclusively supports categories listed in Pixyle’s taxonomy. If you input a category that Pixyle does not support into the 'category' field, the product will still be processed. However, an error will be saved for that product, advising you to review and either add or correct the category accordingly.

If you upload more than one image for the product (image_url_2..8), the system will process all of them and the results will be generated based on all images.
The remaining optional fields do not impact the generated data; thus, the decision to include them is entirely at your discretion.

Upon successful upload, you will receive an immediate confirmation. In the background the system will start with the processing and all products will be processed with all solutions that are active for your account.

Please note that in case of duplicate SKUs within the collection, the system will only process the first occurrence, disregarding subsequent duplicates.

Headers
Authorization Bearer access_token

Parameters
None

Body
Type: multipart/form-data

Headers
Authorization Bearer access_token

Parameters
None

Body
Type: multipart/form-data

file:

(binary) A CSV or JSON file that consists of multiple products.

Response
Returns a JSON object with the following properties:

Response
Returns a list of JSON objects with the following properties:

id:

(string) The unique ID for the uploaded collection in the Pixyle system. You should use this as a reference ID for all other functionalities related for the collection

name:

(string) The name of the collection, it will inherit from the file name that was used to create the collection

product_count:

(int) A number that shows how many products are inside the collection

image_count:

(int) A number that shows how many images are inside the collection

created_at:

(string) A timestamp that shows when was the collection created

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections' \
--header 'Authorization: Bearer eyJhbG...' \
--form 'file=@/path/to/file/test_collection.csv'
POST
/v1/ava/endpoint/ids
const form = new FormData();
form.append('file', File([''], '/path/to/file/test_collection.csv'));

fetch('https://api.pixyle.ai/main/v1/collections', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer eyJhbG...'
    },
    body: form
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

files = {
    'file': open('/path/to/file/test_collection.csv', 'rb'),
}

response = requests.post('https://api.pixyle.ai/main/v1/collections', headers=headers, files=files)

Response:

POST
{
    "message": "Collection created successfully, please check the status of processing data from the uploaded collection on /v1/collections/",
    "id": 123456,
    "name": "test_collection.csv",
    "product_count": 90,
    "image_count": 150,
    "created_at": "Mon, 26 Feb 2024 09:09:51 GMT"
}

Get a collection

GET /collections/{id}

You can check the status of the collection and it’s information on this endpoint, using the previously provided ID.

Headers:
Authorization Bearer access_token

Parameters:

You can retrieve the status and information of the collection by accessing this endpoint and providing the previously provided ID.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID for the uploaded collection in the Pixyle system, that the user wants to check the status for


Body
None

Response
Returns a JSON object with the following properties:

Body:
None

Response:
Returns a JSON object with the following properties:

id:

The unique ID for the uploaded collection in the Pixyle system.

name:

(string) The name of the collection, it will inherit from the file name that was used to create the collection

product_count:

(int) A number that shows how many products are inside the collection

processed_products_percentage:

(float) A percentage number that shows how many products are processed inside the collection

verified_products_percentage:

(float) A percentage number that shows how many products are verified inside the collection

created_at:

(string) A timestamp that shows when was the collection created

updated_at:

(string) A timestamp that shows when was the collection last updated

error_count:

(int) A number that shows how many errors are in the collection

errors:

(list) An array of errors

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections/123456' \
--header 'Authorization: Bearer eyJhbG..'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456', {
  headers: {
    'Authorization': 'Bearer eyJhbG..'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG..',
}

response = requests.get('https://api.pixyle.ai/main/v1/collections/123456', headers=headers)

Response:

POST
{
    "id":123456,
    "name":"test_collection.csv",
    "product_count":90,
    "processed_products_percentage":0.0,
    "verified_products_percentage":0.0,
    "created_at":"Mon, 26 Feb 2024 09:09:51 GMT",
    "updated_at":"Mon, 26 Feb 2024 09:09:51 GMT",
    "error_count":0,
    "errors":[]
}

Rename a collection

PATCH /collections/{id}

This endpoint allows you to rename an uploaded collection in the Pixyle system by providing the unique ID of the collection and the new name.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID of the uploaded collection to be renamed

Body
Type: application/json

Required:

name:

(string) The new name of the collection. The name must adhere to the following rules:

    • Cannot contain special characters.
    • Must not be empty.
    • Must not exceed 128 characters.

Response
Upon successful renaming of the collection, the endpoint returns a JSON object with a confirmation message:

message:

A message that confirms that the collection was successfully renamed.

Example

Request:

POST
curl --location --request PATCH 'https://api.pixyle.ai/main/v1/collections/123456' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "name": "New collection name"
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'name': 'New collection name'
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'name': 'New collection name',
}

response = requests.patch('https://api.pixyle.ai/main/v1/collections/123456', headers=headers, json=json_data)

Response:

POST
{
  "message": "The collection was successfully renamed."
}

Delete a collection

DELETE /collections/{id}

This endpoint allows you to delete an uploaded collection from the Pixyle system by providing the unique ID of the collection.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID of the collection to be deleted from the Pixyle system.

Body
None

Response
Upon successful deletion of the collection, the endpoint returns a JSON object with a confirmation message:

message:

A message that confirms that the collection was successfully deleted.

Example

Request:

POST
curl --location --request DELETE 'https://api.pixyle.ai/main/v1/collections/123456' \
--header 'Authorization: Bearer eyJhbG...'
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

response = requests.delete('https://api.pixyle.ai/main/v1/collections/123456', headers=headers)

Response:

POST
{
  "message": "The collection was successfully deleted."
}

Get all collections

GET /collections?page={}&size={}

This endpoint retrieves a list of all collections that have been processed or are being processed in your account, with support for pagination.

Headers:
Authorization Bearer access_token

Parameters:

This endpoint retrieves a list of all collections that have been processed or are being processed in your account, with support for pagination.

Headers
Authorization Bearer access_token

Parameters

page:

Number of current page used to calculate the offset. Defaults to 1 if missing.

size:

Number of collections to be displayed on each page. Defaults to 7 if missing. The maximum value can be 20.


Body
None

Response
Returns a JSON object with the following properties:

Body:
None

Response:
Returns a JSON object with the following properties:

meta:

(dict) The unique ID for the uploaded collection in the Pixyle system

page:

(int) The page number that was requested

size:

(int) The size number that was requested

total_pages:

(int) The number of total pages that this pagination has

size:

(int) The total number of collections that the user has

result:

(list) A list of objects for each entity

id:

(int)  The unique ID for the uploaded collection in the Pixyle system

name:

(string) The name of the collection, it will inherit from the file name that was used to create the collection

product_count:

(int) A number that indicates how many products are inside the collection

processed_products_percentage:

(float) A percentage number that indicates how many products are processed inside the collection

verified_products_percentage:

(float) A percentage number that indicates how many products are verified inside the collection

created_at:

(string) A timestamp that indicates when was the collection created

updated_at:

(string) A timestamp that indicates when was the collection last updated

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections?page=1&size=7' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections?page=1&size=7', {
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

params = {
    'page': '1',
    'size': '7',
}

response = requests.get('https://api.pixyle.ai/main/v1/collections', params=params, headers=headers)

Response:

POST
{
    "meta": {
        "page": 1,
        "size": 7,
        "total_pages": 14,
        "total": 100
    },
    "result": [
        {
            "id": 1,
            "name": "Spring Collection",
            "product_count": 30,
            "processed_products_percentage": 10.0,
            "verified_products_percentage": 0.0,
            "created_at": "Mon, 26 Feb 2024 13:57:02 GMT",
            "updated_at": "Mon, 26 Feb 2024 13:57:02 GMT"
        },
        {
            "id": 2,
            "name": "Summer Collection",
            "product_count": 100,
            "processed_products_percentage": 100.0,
            "verified_products_percentage": 0.0,
            "created_at": "Mon, 26 Feb 2024 13:57:02 GMT",
            "updated_at": "Mon, 26 Feb 2024 13:57:02 GMT"
        },
        // Additional collections...
    ]
}

Export a collection

POST /collections/{id}/export/{format}


This endpoints allows you to download all the generated data for all products in a specified collection. The data can be downloaded in a CSV or a JSON file.
Even if your collection isn't fully processed, this endpoint will provide data for all the products that have been processed up to the moment you make the request.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID for the uploaded collection in the Pixyle system, the data to be downloaded belongs to

format:

The format of the file in which the data should be returned

Body
None

Response
Returns a JSON or CSV file

Example

Request:

POST
curl --location --request GET 'https://api.pixyle.ai/main/v1/collections/123456/export/csv' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/export/csv', {
    headers: {
        'Authorization': 'Bearer eyJhbG...'
    }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

response = requests.get('https://api.pixyle.ai/main/v1/collections/123456/export/csv', headers=headers)

Response:

POST
(binary file) 

Products in a collection

Add products in a collection

POST /collections/{id}/products

This endpoint allows you to add products in an already created collection.

Headers
Authorization Bearer access_token

Parameters

This endpoint allows you to add products in an already created collection.

Headers:
Authorization Bearer access_token

Parameters:

id:

The unique ID of the collection to which new products will be added

Body:
Type: multipart/form-data


Body
Type: multipart/form-data

file:

(binary) A CSV or JSON file that consists of multiple products. Please refer to this block for file requirements.


Response
Returns a JSON object with the following properties:

Response:
Returns a JSON object with the following properties:

id:

(string) The unique ID for the upgraded collection in the Pixyle system

name:

(string) The name of the collection, it will stay the same

product_count:

(int) An updated number that indicates how many products are inside the collection + the number of products that are added

image_count:

(int) An updated number that indicates how many images are inside the collection + the number of images that are added

created_at:

(string) A timestamp that indicates when was the original collection created

updated_at:

(string) A timestamp that indicates when was the collection last updated

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections/123456/products' \
--header 'Authorization: Bearer eyJhbG...' \
--form 'file=@/path/to/file/add_collection.csv'
POST
/v1/ava/endpoint/ids
const form = new FormData();
form.append('file', File([''], '/path/to/file/add_collection.csv'));

fetch('https://api.pixyle.ai/main/v1/collections/123456/products', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  },
  body: form
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

files = {
    'file': open('/path/to/file/add_collection.csv', 'rb'),
}

response = requests.post('https://api.pixyle.ai/main/v1/collections/123456/products', headers=headers, files=files)

Response:

POST
{
    "id": 123456,
    "name": "add_collection.csv",
    "product_count": 10,
    "image_count": 20,
    "created_at": "Tue, 27 Feb 2024 09:58:12 GMT",
    "updated_at": "Tue, 27 Feb 2024 09:58:12 GMT"
}

Get products from a collection

GET /collections/{id}/products?page={}&size={}

This endpoint retrieves a paginated list of products from a specified collection.

Headers:
Authorization Bearer access_token

Parameters:

This endpoint retrieves a paginated list of products from a specified collection.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID of the uploaded collection in the Pixyle system, that you want to retrieve products.

Pagination query parameters:

Pagination query parameters:

page:

Number of current page used to calculate the offset. Defaults to 1 if missing.

size:

Number of product to be displayed on each page. Defaults to 10 if missing. The maximum value can be 50.

sort_by:

A value according to which the product should be sorted in the response. Possible values:
- updated_at

updated_at

order:

The order of the sorting. Possible values:
- asc (default)
- desc

asc (default)

desc

Body:
None

Response
Returns a JSON object with the following properties:

Body
None

Response
Returns a JSON object with the following properties:

meta:

(dict) A dict that keeps meta data regarding the response

page:

(int) The page number that was requested

size:

(int) The size number that was requested

total_pages:

(int) The number of total pages that this pagination has

total:

(int) The total number of products that are present in this collection

result:

(list) A list of objects for each product

sku:

(string) The SKU of the product

image_url_1:

(string) The image_url_1 of the product

verified:

(boolean) A flag that indicates if the product is verified

processed:

(boolean) A flag that indicates if the products is processed

verified_product_percentage:

(float) A number that indicates the percentage of verification completed for the product

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections/123456/products?page=1&size=20&sort_by=updated_at&order=desc' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products?page=1&size=20&sort_by=updated_at&order=desc', {
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

params = {
    'page': '1',
    'size': '20',
    'sort_by': 'updated_at',
    'order': 'desc',
}

response = requests.get('https://api.pixyle.ai/main/v1/collections/123456/products', params=params, headers=headers)

Response:

POST

{
    "meta": {
        "page": 1,
        "size": 20,
        "total_pages": 5,
        "total": 100
    },
    "result": [
        {
            "sku": "1",
            "image_url_1": "https://www.pixyle.ai/img.jpg",
            "verified": true,
            "verified_product_percentage": 100.00
        },
        {
            "sku": "2",
            "image_url_1": "https://www.pixyle.ai/img.jpg",
            "verified": true,
            "verified_product_percentage": 100.00
        },
        {
            "sku": "3",
            "image_url_1": "https://www.pixyle.ai/img.jpg",
            "verified": true,
            "verified_product_percentage": 100.00
        },
        // Additional products...
    ]
}

Get product from a collection

GET /collections/{id}/products/{sku}

This endpoint allows you to get specific product and its result from a processed collection.

Headers
Authorization Bearer access_token

Parameters

This endpoint allows you to get specific product and its result from a processed collection.

Headers:
Authorization Bearer access_token

Parameters:

id:

The unique ID for the uploaded collection in the Pixyle system, that the product belongs to

sku:

The SKU of the product

Body
None

Response
Returns a JSON object with the following properties:

Body
None

Response
Returns a JSON object with the following properties:

sku:

(string) The SKU of the product

errors:

(list) A list of error objects associated with the product

verified:

(boolean) A flag that indicates if the complete product is verified

result:

(list) A list with result object for each detected fashion item in the images

verified_product_percentage:

(float) A number that indicates the percentage of verification completed for the product

primary_image:

(string) An image from the products list of images which is detected as a primary image of the product

extra_images:

(list) A list of extra images for the product

primary_detection:

(boolean) A boolean flag that indicates if the detected item is the primary product

detection_id:

(int) The unique Pixyle Detection ID for this fashion item

features:

(list) A list that contains objects for each feature result

feature_name:

(string) The name of the feature that this result is for

verified:

(boolean) A flag that shows if this feature result is verified for this product

feature_result:

An object/list that represents the result of this feature

For "bounding_box":

Contains the top-left (x_min, y_min) and bottom-right (x_max, y_max) corners of the bounding box

x_min:

(float) Represents the minimum value of the x-coordinate in the bounding box

y_min:

(float) Represents the minimum value of the y-coordinate in the bounding box

x_max:

(float) Represents the minimum value of the x-coordinate in the bounding box

y_max:

(float) Represents the minimum value of the y-coordinate in the bounding box

For "automatic_tagging":

Contains an array of objects representing different types of generated tags

tags_type:

(string) Indicates the type of the generated tags

tags:

(list) A list of objects representing individual tags associated with the tags_type

·

value:

(string) Represents generated tag

·

score:

(float) Indicates the confidence score associated with the generated tag

For "label_recognition":

Contains an array of objects representing different types of generated tags

tags_type:

(string) Indicates the type of the generated tags

tags:

(list) A list of objects representing individual tags associated with the tags_type

·

value:

(string) Represents generated tag

·

metadata:

Additional metadata associated with a tag

meta_key:

(string) Represents the key of the metadata

meta_value:

(string) Represents the value of the metadata

For "title_generation", and "description_generation":

Contains an array of objects representing the generated data in different languages.

value:

(string) Represents the generated title/description

language:

(string) Represents the language of the generated title/description

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/collections/123456/products/1' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/1', {
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

response = requests.get('https://api.pixyle.ai/main/v1/collections/123456/products/1', headers=headers)

Response:

POST
{
    "errors": [],
    "sku": "1",
    "verified": false,
    "result": [
        {
            "verified_product_percentage": 20.00,
            "primary_image": "https://www.pixyle.ai/img.jpg",
            "extra_images": [
                "https://www.pixyle.ai/extra_img_1.jpg",
                "https://www.pixyle.ai/extra_img_2.jpg",
                "https://www.pixyle.ai/extra_img_3.jpg",
                "https://www.pixyle.ai/extra_img_4.jpg"
            ],
            "primary_detection": true,
            "detection_id": 1,
            "features": [
                {
                    "feature_name": "bounding_box",
                    "verified": false,
                    "feature_result": {
                        "x_max": 1021.45,
                        "x_min": 465.94,
                        "y_max": 1616.13,
                        "y_min": 438.91
                    }
                },
                {
                    "feature_name": "automatic_tagging",
                    "verified": false,
                    "feature_result": [
                        {
                            "tags_type": "category",
                            "tags": [
                                {
                                    "value": "dress",
                                    "score": 0.77948
                                }
                            ],
                            "options": [
                                "blouse",
                                "coat",
                                "skirt",
                                // Additional options
                            ]
                        },
                        {
                            "tags_type": "neckline_type",
                            "tags": [
                                {
                                    "value": "round-neck",
                                    "score": 0.77948
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "sleeve_length",
                            "tags": [
                                {
                                    "value": "short-sleeve",
                                    "score": 0.99961
                                }
                            ],
                            "options": [...]
                        },
                        {
                            "tags_type": "colors",
                            "tags": [
                                {
                                    "value": "bordeaux",
                                    "score": 0.71499
                                },
                                {
                                    "value": "black",
                                    "score": 0.22111
                                }
                            ],
                            "options": [...]
                        },
                        {...}
                    ]
                },
                {
                    "feature_name": "label_recognition",
                    "verified": false,
                    "feature_result": [
                        {
                            "tags_type": "brand",
                            "tags": [
                                {
                                    "value": "Zara",
                                    "metadata": []
                                }
                            ]
                        },
                        {
                            "tags_type": "made_in",
                            "tags": [
                                {
                                    "value": "India",
                                    "metadata": []
                                }
                            ]
                        },
                        {
                            "tags_type": "size",
                            "tags": [
                                {
                                    "value": "8",
                                    "metadata": [
                                        {
                                            "meta_key": "size_type",
                                            "meta_value": "UK"
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            "tags_type": "size",
                            "tags": [
                                {
                                    "value": "4",
                                    "metadata": [
                                        {
                                            "meta_key": "size_type",
                                            "meta_value": "US"
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            "tags_type": "material",
                            "tags": [
                                {
                                    "value": "polyester",
                                    "metadata": [
                                        {
                                            "meta_key": "material_percentage",
                                            "meta_value": "57"
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                },
                {
                    "feature_name": "title_generation",
                    "verified": false,
                    "feature_result": [
                        {
                            "value": "Casual Midi Dress",
                            "language": "English"
                        },
                        {
                            "value": "Robe midi décontractée",
                            "language": "French"
                        }
                    ]
                },
                {
                    "feature_name": "description_generation",
                    "verified": false,
                    "feature_result": [
                        {
                            "value": "Introducing our luxurious lace and silk dress, designed with the sophisticated woman in mind...",
                            "language": "English"
                        },
                        {
                            "value": "Voici notre luxueuse robe en dentelle et soie, conçue pour les femmes sophistiquées...",
                            "language": "French"
                        }
                    ]
                }
            ]
        }
    ]
}

Delete product from a collection

DELETE /collections/{id}/products/{sku}

This endpoint allows you to delete a product from a collection.

Headers:
Authorization Bearer access_token

Parameters:

This endpoint allows you to delete a product from a collection.

Headers
Authorization Bearer access_token

Parameters

id:

The unique ID for the uploaded collection in the Pixyle system, that the product to be deleted, belongs to

sku:

The SKU of the product to be deleted

Body
None

Response
Upon successful deletion of the product, the endpoint returns a JSON object with a confirmation message:

Body:
N
‍‍

Response:
Upon successful deletion of the product, the endpoint returns a JSON object with a confirmation message:

message:

(str) A message that confirms that the product was successfully deleted.

Example

Request:

POST
curl --location --request DELETE 'https://api.pixyle.ai/main/v1/collections/123456/products/2' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/2', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

response = requests.delete('https://api.pixyle.ai/main/v1/collections/123456/products/2', headers=headers)

Response:

POST
{
  "message": "The product was successfully deleted."
}

Update product from a collection

PATCH /collections/{id}/products/{sku}

This endpoint allows you to update the generated data for a processed product from a collection. The process of update of the generated data is perceived as a Human verification step, which means that either the human approves the generated data or corrects it. This means that the data is reviewed by human and it’s free for usage.
Only the generated data for the primary product can be updated and marked as verified.

Headers
Authorization Bearer access_token

Parameters

This endpoint allows you to update the generated data for a processed product from a collection. The process of update of the generated data is perceived as a Human verification step, which means that either the human approves the generated data or corrects it. This means that the data is reviewed by human and it’s free for usage.
Only the generated data for the primary product can be updated and marked as verified.

Headers:
Authorization Bearer access_token

Parameters:

id:

The unique ID for the uploaded collection in the Pixyle system, that the product to be updated, belongs to

sku:

The SKU of the product to be updated

Body
Upon successful deletion of the product, the endpoint returns a JSON object with a confirmation message:

Body
Only the data that should be updated, should be present in the body.

feature_name:

(string) The name of the feature that the updated data is for

verified:

(boolean) A flag that shows the new verified state for this feature (it should always be true)

feature_result:

An object/list that represents the updated data of this feature. If there's no need to update any data and you simply wish to confirm the generated data, you can send an empty object/list or not include this key at all.

For "bounding_box":

x_min:

(float) The new value

y_min:

(float) The new value

x_max:

(float) The new value

y_max:

(float) The new value

For "automatic_tagging":

tags_type:

(string) Indicates the type of the generated tag that should be updated

tags:

(list) A list of objects representing individual tags that should be updated, associated with the tags_type

·

old_value:

(string) Represents the old generated tag that should be updated (null, if you want to add a tag)

·

new_value:

(string) Represents the new value of the generated tag (null, if you want to delete a tag)

For "label_recognition":

tags_type:

(string) Indicates the type of the generated tag that should be updated

tags_type:

(list) A list of objects representing individual tags associated with the tags_type

·

old_value:

(string) Represents the old generated tag that should be updated (null, if you want to add a tag)

·

new_value:

(string) Represents the new value of the generated tag (null, if you want to delete a tag)

·

value:

(string) Represents the value of the generated tags on which you only want to update the metadata, but not the tag itself

·

new_metadata:

The new metadata that should be associated with the tag

meta_key:

(string) Represents the key of the metadata

meta_value:

(string) Represents the value of the metadata

For "title_generation", and "description_generation":

new_value:

(string) Represents the new title/description

language:

(float) Represents the language of the generated title/description

Response
Returns a JSON object with the following properties:

Response
Returns a JSON object with the following properties:

message:

(string) Confirmation message that the update was successful

updated_products:

(list) List of one object with the new state of the updated product

sku:

(string) The SKU of the product

verified:

(boolean) A flag that indicates if the complete product is verified

result:

(list) A list with result object with the new state of the primary product

verified_product_percentage:

(float) A number that indicates the percentage of verification completed for the product

primary_image:

(string) An image from the products list of images which is detected as a primary image of the product

features

(list) A list that contains objects for each feature result

feature_name:

(string) The name of the feature that this result is for

verified:

(boolean) A flag that shows if this feature result is verified for this product

Example

Request:

POST
curl --location --request PATCH 'https://api.pixyle.ai/main/v1/collections/123456/products/1' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "features": [
        {
            "feature_name": "bounding_box",
            "verified": true,
            "feature_result": {
                "x_min": 100.50,
                "y_max": 1200.0
            }
        },
        {
            "feature_name": "automatic_tagging",
            "verified": true,
            "feature_result": [
                {
                    "tags_type": "colors",
                    "tags": [
                        {
                            "old_value": "bordeaux",
                            "new_value": null
                        },
                        {
                            "old_value": "black",
                            "new_value": "red"
                        }
                    ]
                },
                {
                    "tags_type": "neckline_type",
                    "tags": [
                        {
                            "old_value": "round-neck",
                            "new_value": "v-neck"
                        }
                    ]
                }
            ]
        },
        {
            "feature_name": "label_recognition",
            "verified": true,
            "feature_result": [
                {
                    "tags_type": "brand",
                    "tags": [
                        {
                            "old_value": "Zara",
                            "new_value": "Oh Polly"
                        }
                    ]
                },
                {
                    "tags_type": "size",
                    "tags": [
                        {
                            "old_value": "8",
                            "new_value": "6"
                        }
                    ]
                },
                {
                    "tags_type": "material",
                    "tags": [
                        {
                            "value": "polyester",
                            "new_metadata": [
                                {
                                    "meta_key": "material_percentage",
                                    "meta_value": "50 %"
                                }
                            ]
                        },
                        {
                            "old_value": null,
                            "new_value": "coton"
                        }
                    ]
                }
            ]
        },
        {
            "feature_name": "title_generation",
            "verified": true,
            "feature_result": [
                {
                    "language": "English",
                    "new_value": "New Title Generated"
                },
                {
                    "language": "French",
                    "new_value": "Nouveau titre généré"
                }
            ]
        },
        {
            "feature_name": "description_generation",
            "verified": true,
            "feature_result": [
                {
                    "language": "English",
                    "new_value": "New Description Generated"
                }
            ]
        }
    ]
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/1', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'features': [
      {
        'feature_name': 'bounding_box',
        'verified': true,
        'feature_result': {
          'x_min': 100.5,
          'y_max': 12
        }
      },
      {
        'feature_name': 'automatic_tagging',
        'verified': true,
        'feature_result': [
          {
            'tags_type': 'colors',
            'tags': [
              {
                'old_value': 'bordeaux',
                'new_value': null
              },
              {
                'old_value': 'black',
                'new_value': 'red'
              }
            ]
          },
          {
            'tags_type': 'neckline_type',
            'tags': [
              {
                'old_value': 'round-neck',
                'new_value': 'v-neck'
              }
            ]
          }
        ]
      },
      {
        'feature_name': 'label_recognition',
        'verified': true,
        'feature_result': [
          {
            'tags_type': 'brand',
            'tags': [
              {
                'old_value': 'Zara',
                'new_value': 'Oh Polly'
              }
            ]
          },
          {
            'tags_type': 'size',
            'tags': [
              {
                'old_value': '8',
                'new_value': '6'
              }
            ]
          },
          {
            'tags_type': 'material',
            'tags': [
              {
                'value': 'polyester',
                'new_metadata': [
                  {
                    'meta_key': 'material_percentage',
                    'meta_value': '50 %'
                  }
                ]
              },
              {
                'old_value': null,
                'new_value': 'coton'
              }
            ]
          }
        ]
      },
      {
        'feature_name': 'title_generation',
        'verified': true,
        'feature_result': [
          {
            'language': 'English',
            'new_value': 'New Title Generated'
          },
          {
            'language': 'French',
            'new_value': 'Nouveau titre généré'
          }
        ]
      },
      {
        'feature_name': 'description_generation',
        'verified': true,
        'feature_result': [
          {
            'language': 'English',
            'new_value': 'New Desc Generated'
          }
        ]
      }
    ]
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'features': [
        {
            'feature_name': 'bounding_box',
            'verified': True,
            'feature_result': {
                'x_min': 100.5,
                'y_max': 1200,
            },
        },
        {
            'feature_name': 'automatic_tagging',
            'verified': True,
            'feature_result': [
                {
                    'tags_type': 'colors',
                    'tags': [
                        {
                            'old_value': 'bordeaux',
                            'new_value': None,
                        },
                        {
                            'old_value': 'black',
                            'new_value': 'red',
                        },
                    ],
                },
                {
                    'tags_type': 'neckline_type',
                    'tags': [
                        {
                            'old_value': 'round-neck',
                            'new_value': 'v-neck',
                        },
                    ],
                },
            ],
        },
        {
            'feature_name': 'label_recognition',
            'verified': True,
            'feature_result': [
                {
                    'tags_type': 'brand',
                    'tags': [
                        {
                            'old_value': 'Zara',
                            'new_value': 'Oh Polly',
                        },
                    ],
                },
                {
                    'tags_type': 'size',
                    'tags': [
                        {
                            'old_value': '8',
                            'new_value': '6',
                        },
                    ],
                },
                {
                    'tags_type': 'material',
                    'tags': [
                        {
                            'value': 'polyester',
                            'new_metadata': [
                                {
                                    'meta_key': 'material_percentage',
                                    'meta_value': '50 %',
                                },
                            ],
                        },
                        {
                            'old_value': None,
                            'new_value': 'coton',
                        },
                    ],
                },
            ],
        },
        {
            'feature_name': 'title_generation',
            'verified': True,
            'feature_result': [
                {
                    'language': 'English',
                    'new_value': 'New Title Generated',
                },
                {
                    'language': 'French',
                    'new_value': 'Nouveau titre généré',
                },
            ],
        },
        {
            'feature_name': 'description_generation',
            'verified': True,
            'feature_result': [
                {
                    'language': 'English',
                    'new_value': 'New Description Generated',
                },
            ],
        },
    ],
}

response = requests.patch('https://api.pixyle.ai/main/v1/collections/123456/products/1', headers=headers, json=json_data)

Example

Create/Update metadata on present value example:

POST
curl --location --request PATCH 'https://api.pixyle.ai/main/v1/collections/123456/products/1' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "features": [
        {
            "feature_name": "label_recognition",
            "verified": true,
            "feature_result": [
                {
                    "tags_type": "material",
                    "tags": [
                        {
                            "value": "polyester",
                            "new_metadata": [
                                {
                                    "meta_key": "material_percentage",
                                    "meta_value": "20 %"
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/1', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'features': [
      {
        'feature_name': 'label_recognition',
        'verified': true,
        'feature_result': [
          {
            'tags_type': 'material',
            'tags': [
              {
                'value': 'polyester',
                'new_metadata': [
                  {
                    'meta_key': 'material_percentage',
                    'meta_value': '20 %'
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'features': [
        {
            'feature_name': 'label_recognition',
            'verified': True,
            'feature_result': [
                {
                    'tags_type': 'material',
                    'tags': [
                        {
                            'value': 'polyester',
                            'new_metadata': [
                                {
                                    'meta_key': 'material_percentage',
                                    'meta_value': '20 %',
                                },
                            ],
                        },
                    ],
                },
            ],
        },
    ],
}

response = requests.patch('https://api.pixyle.ai/main/v1/collections/123456/products/1', headers=headers, json=json_data)

Example

Delete metadata on present value example:

POST
curl --location --request PATCH 'https://api.pixyle.ai/main/v1/collections/123456/products/1' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "features": [
        {
            "feature_name": "label_recognition",
            "verified": true,
            "feature_result": [
                {
                    "tags_type": "material",
                    "tags": [
                        {
                            "value": "polyester",
                            "new_metadata": []
                        }
                    ]
                }
            ]
        }
    ]
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/1', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'features': [
      {
        'feature_name': 'label_recognition',
        'verified': true,
        'feature_result': [
          {
            'tags_type': 'material',
            'tags': [
              {
                'value': 'polyester',
                'new_metadata': []
              }
            ]
          }
        ]
      }
    ]
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'features': [
        {
            'feature_name': 'label_recognition',
            'verified': True,
            'feature_result': [
                {
                    'tags_type': 'material',
                    'tags': [
                        {
                            'value': 'polyester',
                            'new_metadata': [],
                        },
                    ],
                },
            ],
        },
    ],
}

response = requests.patch('https://api.pixyle.ai/main/v1/collections/123456/products/1', headers=headers, json=json_data)

Example

Create metadata on new value example:

POST
curl --location --request PATCH 'https://api.pixyle.ai/main/v1/collections/123456/products/1' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer eyJhbG...' \
--data '{
    "features": [
        {
            "feature_name": "label_recognition",
            "verified": true,
            "feature_result": [
                {
                    "tags_type": "material",
                    "tags": [
                        {
                            "old_value": "polyester",
                            "new_value": "cotton",
                            "new_metadata": [
                                {
                                    "meta_key": "material_percentage",
                                    "meta_value": "80 %"
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/collections/123456/products/1', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer eyJhbG...'
  },
  body: JSON.stringify({
    'features': [
      {
        'feature_name': 'label_recognition',
        'verified': true,
        'feature_result': [
          {
            'tags_type': 'material',
            'tags': [
              {
                'old_value': 'polyester',
                'new_value': 'cotton',
                'new_metadata': [
                  {
                    'meta_key': 'material_percentage',
                    'meta_value': '80 %'
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  })
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

json_data = {
    'features': [
        {
            'feature_name': 'label_recognition',
            'verified': True,
            'feature_result': [
                {
                    'tags_type': 'material',
                    'tags': [
                        {
                            'old_value': 'polyester',
                            'new_value': 'cotton',
                            'new_metadata': [
                                {
                                    'meta_key': 'material_percentage',
                                    'meta_value': '80 %',
                                },
                            ],
                        },
                    ],
                },
            ],
        },
    ],
}

response = requests.patch('https://api.pixyle.ai/main/v1/collections/123456/products/1', headers=headers, json=json_data)

Response:

POST
{
    "message": "The product was successfully verified.",
    "updated_products": [
        {
            "sku": "1",
            "result": [
                {
                    "verified": true,
                    "verified_product_percentage": 100.0,
                    "primary_image": "https://www.pixyle.ai/img.jpg",
                    "features": [
                        {
                            "feature_name": "bounding_box",
                            "verified": true
                        },
                        {
                            "feature_name": "automatic_tagging",
                            "verified": true
                        },
                        {
                            "feature_name": "label_recognition",
                            "verified": true
                        },
                        {
                            "feature_name": "title_generation",
                            "verified": true
                        },
                        {
                            "feature_name": "description_generation",
                            "verified": true
                        }
                    ]
                }
            ]
        }
    ]
}

Analytics

Get analytics

GET /analytics?start_date={}&end_date={}

This endpoint retrieves comprehensive analytics data, providing insights into various metrics such as product performance, user engagement, and overall platform usage.

Headers
Authorization Bearer access_token

Parameters

This endpoint retrieves comprehensive analytics data, providing insights into various metrics such as product performance, user engagement, and overall platform usage.

Headers:
Authorization Bearer access_token

Parameters:

start_date:

Specifies the starting date from which the analytics data should be retrieved (Format: YYYY-MM-DD)

end_date:

Specifies the ending date from which the analytics data should be retrieved (Format: YYYY-MM-DD)

last24_h:

A flag that represents if the time-frame for the analytics data is 24 hours. If set to true, the response contains analytics for the last 24 hours (Values: true, false)

features:

A list of features for which the user wants to filter the products

Body
None

Response
Returns a JSON object with the following properties:

Body:
None

Response:
Returns a JSON object with the following properties:

time_series_features_data:

(list) A list of objects with time-series analytics for each feature

timestamp:

(date) Represents the date/hour for which the analytics are returned

feature_name:

(string) Represents the name of the feature for which the analytics are returned

processed_listings_count:

(int) Indicates how many products were processed with that feature

data_points_count:

(int) Indicates how many data points the AI generated for that feature

processing_time_seconds:

(int) Indicates how much time the AI spent on processing

time_series_overall_data:

(list) A list of objects with overall time-series analytics

timestamp:

(date) Represents the date/hour for which the analytics are returned

upload_listings_count:

(int) Indicates the number of products that were uploaded

processed_listings_count:

(int) Indicates  the number of products that were processed

data_points_count:

(int) Indicates how many data points the AI generated

processing_time_seconds:

(int) Indicates how much time the AI spent on processing

overall_data:

(dict) A dict that holds the overall analytics

manual_avg_processing_time:

(bigint) Represents how much time it would take to manually assign data points to the processed products (in seconds)

ai_processing_time:

(int) Represents how much time it took the AI to assign data points to the processed products (in seconds)

processed_listings_count:

(int) Indicates how many products were processed

data_points_count:

(int) Indicates how many data points the AI generated

time_saved:

(float) Indicates how much time you will save by using Pixyle services (per collection) (in seconds)

Example

Request:

POST
curl --location 'https://api.pixyle.ai/main/v1/analytics?start_date=2022-05-05&end_date=2023-06-10' \
--header 'Authorization: Bearer eyJhbG...'
POST
/v1/ava/endpoint/ids
fetch('https://api.pixyle.ai/main/v1/analytics?start_date=2022-05-05&end_date=2023-06-10', {
  headers: {
    'Authorization': 'Bearer eyJhbG...'
  }
});
POST
/v1/ava/endpoint/ids
import requests

headers = {
    'Authorization': 'Bearer eyJhbG...',
}

params = {
    'start_date': '2022-05-05',
    'end_date': '2023-06-10',
}

response = requests.get('https://api.pixyle.ai/main/v1/analytics', params=params, headers=headers)

Response:

POST
{
    "time_series_features_data": [
        {
            "timestamp": "2023-05-24T00:00:00+00:00",
            "feature_name": "bounding_box",
            "processed_listings_count": 0,
            "data_points_count": 0,
            "processing_time_seconds": 0
        },
        {
            "timestamp": "2023-05-24T00:00:00+00:00",
            "feature_name": "label_recognition",
            "processed_listings_count": 0,
            "data_points_count": 0,
            "processing_time_seconds": 0
        },
        {
            "timestamp": "2023-05-24T00:00:00+00:00",
            "feature_name": "automatic_tagging",
            "processed_listings_count": 0,
            "data_points_count": 0,
            "processing_time_seconds": 0
        },
        // Additional objects
    ],
    "time_series_overall_data": [
        {
            "timestamp": "2023-05-24T00:00:00+00:00",
            "upload_listings_count": 0,
            "processed_listings_count": 0,
            "data_points_count": 0,
            "processing_time_seconds": 0
        },
        {
            "timestamp": "2023-05-25T00:00:00+00:00",
            "upload_listings_count": 4756904,
            "processed_listings_count": 1199772,
            "data_points_count": 8773128,
            "processing_time_seconds": 1800775.88
        },
        {
            "timestamp": "2023-05-26T00:00:00+00:00",
            "upload_listings_count": 3385840,
            "processed_listings_count": 2088580,
            "data_points_count": 14616992,
            "processing_time_seconds": 3131945.88
        },
        // Additional objects
    ],
    "overall_data": {
        "manual_avg_processing_time": 701703600,
        "ai_processing_time": 4932721.76,
        "processed_listings_count": 3288352,
        "data_points_count": 23390120,
        "time_saved": 696770878.24
    }
}

Dashboard guide

Welcome to the user guide for the Pixyle.ai Dashboard! This guide is designed to help you navigate and utilize the features of our dashboard effectively. Whether you're a beginner or an experienced user, this guide will provide you with the necessary information to make the most out of your dashboard experience.

Introduction
The Pixyle.ai dashboard serves as a platform and central hub for uploading and/or accessing data related to your organization and the features you have decided to use. It provides a step by step guide for all supported features. If it is something interesting to you but you still haven’t had that feature available, please get in contact with us.

Getting started

Logging In:
Please contact us in order to access the dashboard. You will then receive an email from Pixyle with information of your new account and option to set up a password in within next 24 hours. Once you set your account, for the future sign in use those credentials. If you haven’t receive the email please check all folders including spam.

image get start

If you try to use the link after 24 hours you will be informed that the link has expired and you will receive new email from Pixyle.ai with new link.  
In case you forgot your password, use forget password option. You will receive email with code that you need to insert it and after that you will receive link to reset the password.

Navigating the Dashboard:
Once logged in, you'll see a navigation menu that allow you to access different sections of the dashboard on one side and your analytics or home page on the other side.

The available options are:
• Add new collection
• Analytics
• Collections

Dashboard widgets

Widgets:
In the analytics page allows you to have visual representation of data through various charts and graphs to help you gain insights quickly regarding your current work status as well as value that Pixyle.ai brings to your business.

image dashboard

Toggle to display or hide the graphical representation depicting the quantity of products processed within the specified timeframe.

image dashboard

Filtering data

Utilize time filters to tailor the data showcased on the dashboard, either by selecting from predefined timeframes or opting for a custom timeframe of your choice

image filter

Upload collection

To upload a collection along with images for processing, you have two options: either use the "+" button located in the top of the menu bar, or “+ New Collection” button in the 'Collections' option, which is the third choice in the menu bar.

Filter data

You can upload files in either CSV or JSON format containing lists of images, each file having a maximum size of 32 MB. Below the upload option, you'll find example files in both JSON and CSV formats, which serve as helpful references to expedite your utilization of Pixyle.ai's features. In case you experience an error you can check the respective error reference here.

upload collection

All Collections

After uploading your collection, you will be redirected to the 'All Collections' page, where you can access the following:

• A comprehensive list of all collections, whether uploaded recently or previously.
• Each collection's name can be updated by clicking the 'Edit' option located in the right corner of the collection title.
• A display of several images from each collection, aiding in easy recognition, along with the total number of images in the collection.
• The processing status of each collection.
• The progress of its validation, if you are utilizing this feature.
• The timestamp indicating when the collection was last updated.
• An option to add additional images to the collection.Lastly, additional options specific to each collection.

all collections

As additional option, in the menu represented by three dots in the right corner, you can access several options:

• Check for any errors or warnings that may have occurred during processing.
• Once processing is completed, export the results in the required file format.
• Additionally, you have the option to delete the collection if it's no longer needed.

error drop

Collection

With click on collection name you will be redirected to the inside of the collection. If you are using validation option you will see for each images the status of content validation. In the top row you will find statistics of that collection containing valuable information.

From this screen, you can perform the following actions:
1. Utilize filters to locate specific images within the collection.
2. Sort the collection by various criteria.
3. Review the generated values for a single image.
4. Initiate bulk verification for a desired sample of images.

image collection

1. To view specific images or results from a particular feature used in the collection, navigate to the filter tab and select your desired criteria. You can filter by date, categories, verification status, and the features utilized.

image popup

2. In addition, you have the option to sort the images within the collection according to various criteria.

image dropdown

3. The Product Page provides an overview of all supported features, including those you've enabled. At the top of the page, you'll find shortcuts to all available features, indicating which ones are enabled and which ones you haven't selected yet.

In the main tags section, you'll find tags generated by our Automatic Tagging AI solution. If you're using the verification option, you can assess the accuracy of these tags and make updates as necessary. Clicking the 'Verify' button saves any changes made.

In the locked tags section, you'll find tags generated by the same AI solution, but these are tags that cannot be modified.

Towards the top of the page, you'll find the title and description generated by AI using the tags generated for the product. If translation is available, you can select a different language, and below the initially generated title and description, you'll see the translated version.

To make changes, simply click on the text to enter edit mode. Click 'Verify Changes' to save any modifications. If you're unsatisfied with the generated title or description, you can regenerate them.

Another available option is label tags, which are generated by our label recognition AI solution.
If all generated values are correct, you can use the option to verify all changes made on the page.
For easy navigation between products, you'll find a navigation bar above the main image, allowing you to select the next desired image.

image product profile

4. To streamline the verification process of generated data, we offer the bulk verification option.
Once you've selected the filter criteria for the data you wish to verify, you'll be presented with multiple images and their associated values on a single screen.

From here, you have the choice to either verify all directly or edit individual values before verification

image bulk verification

Congratulations! You are now equipped with the knowledge to navigate and utilize the dashboard effectively. We hope this user guide enhances your experience and helps you derive valuable insights and value. If you have any further questions or need assistance, don't hesitate to reach out to us. Happy dashboarding!

We Value Your Feedback: Your feedback is essential for us to continually improve the dashboard. Please contact us and share any suggestions or feature requests with us so that we can enhance your dashboard experience.

FAQ

Does the model try to fill every attribute for a product or is it based on the taxonomy hierarchy in Pixyle?

The model fills in only the relevant attributes that are present in Pixyle’s standard taxonomy based on the taxonomy hierarchy. This means if the model detects a skirt, it will fill in only the skirt's relevant attributes (eg. it will not fill in sleeve length or neckline type).

Can your platform detect multiple fashion items in an image?

Yes, we can set our platform to detect every fashion item present in an image and assign specific attributes for each of those items. Another option is to set up the platform to detect only one (the biggest item) in the image.

Is it possible to give feedback on the quality of the results?

Yes, you can send us your feedback on the results in three ways:
1.) Validate images through our dashboard manually, one by one. This feedback will be sent to our system automatically;
2.) Validate images on your side (eg. if you already using a tool to create, update and insert the products in the system), and then send us the feedback through API on our validation endpoint;
3.) Do a manual analysis with any file type (CSV/JSON/XLS), and send us the file. We will then consolidate it and use the feedback to improve the model.

Is there a size limit to the CSV file and a limitation for rows in the CSV?

We have a limit of 30MB for the size of the CSV for the request payload. You will receive the “We are unable to process this file” message due to the bigger size of the CSV file. We do not have a limit on the number of rows, but we recommend not more than 100k for better organization and maintenance.

What happens if we add a product with a duplicate product id to a collection?

The product SKU is a unique object for each product in the dataset. In case of duplicate SKUs within the collection, the system will only process the first occurrence, disregarding subsequent duplicates.

What is the standard throughput?

Collection upload - By default, you can upload a maximum of 1 collection per second.
Product upload - By default, you can upload a maximum of 2 products per second.

Please contact us if you need higher throughput.

What does a taxonomy mapping represent?

Mapping represents an exercise where we associate each element of your taxonomy with one or more elements of our taxonomy.

This means that you will get the categories and attributes in your naming and in your structure.The taxonomy mapping is done at the beginning of the collaboration.

Is my data safe?

Yes, we take the security of your data very seriously. Here's how we ensure its safety:

Encryption: We use HTTPS (Hypertext Transfer Protocol Secure) for all communication between your application and our servers. This ensures that data transmitted over the network is encrypted and protected from unauthorized access.

Hosting on Google Cloud: Our servers are hosted on Google Cloud, which provides robust security measures and infrastructure to safeguard your data. Google Cloud adheres to industry-leading security standards and compliance certifications to protect your data against unauthorized access, breaches, and data loss.

In addition to these measures, we regularly review and update our security practices to stay ahead of emerging threats and ensure the ongoing safety and integrity of your data.

Release notes

Important information

The Pixyle v1.0.0 currently supports these features:
  ◦ Bounding Box
  ◦ Automatic Tagging
  ◦ Label Recognition
  ◦ Title Generation
  ◦ Description Generation

• The verification process on primary products in collection is available for these features:
  ◦ Automatic Tagging
  ◦ Label Recognition
  ◦ Title Generation
  ◦ Description Generation

Option to receive title and description in multiple languages
Option to add new tags for the label recognition feature
• Comprehensive analytics

Updates

Pixyle API v1.0.0

Features
All mentioned features are supported by the API.
The collection processing mode is available
The real-time processing mode is available
Option to create/upgrade/rename/delete a collection
Option to export the results for a collection
Option to view the errors for products in a collection
Option to verify primary product per feature
Option to delete primary product (and it’s non-primary products) from a collection
Analytics filtering options
  ◦ date

Improvements
None

Bug fixes
None

Pixyle Dashboard v1.0.0


Features

All mentioned features are supported on the dashboard.
Only the collection processing mode is available
Option to create/upgrade/rename/delete a collection
Option to export the results for a collection
Option to view the errors for products in a collection
Option to verify primary product per feature
Option to delete primary product (and it’s non-primary products) from a collection
Products filtering options:
  ◦ date
  ◦ verification status
  ◦ category
  ◦ feature

Products sorting options:
  ◦ updated_at date
  ◦ created_at date

Products ordering options:
  ◦ ascending
  ◦ descending

Analytics filtering options
  ◦ date

Option to review changes in the verification process
Option to re-generate title and description
Option to search by product SKU

Improvements
None

Bug fixes
None