AI Product Description Generator for Marketplaces

Development of AI Product Description Generation System

Manual copywriting for a catalog of 10,000 products takes 3–4 months. An AI system reduces this to a week, generating up to 10,000 descriptions per day — 50–100 times faster than manual work. We use GPT-4o, asynchronous batch processing, and adapters for Wildberries, Ozon, Amazon. In one project for an online store with 15,000 SKUs, we reduced the copywriting budget by an order of magnitude and cut the time to launch on marketplaces from 3 months to 2 weeks.

Why Automation of Descriptions Is Critical for E-commerce

Manual writing does not scale: when the assortment grows from 1,000 to 10,000 SKUs, copywriting costs multiply, and timelines reach 3–4 months. An LLM-based system solves this: once the architecture is developed, you get an unlimited stream of SEO-optimized texts for any platform. LLMs guarantee a consistent style and eliminate typical errors — typos, duplication, mismatched attributes.

What Problems Does the AI Generator Solve?

High cost and long timelines. Manual writing has a high cost per description, and for a catalog of 10,000 products it takes months. Our system reduces cost by an order of magnitude: cost per description becomes negligible, and time drops to 2 seconds.

Inconsistent quality. Different copywriters write differently, harming brand perception. The LLM generator uses a single prompt and rules for each platform, ensuring uniformly high quality for all products.

Limited SEO optimization. Copywriters rarely consider all key queries and search engine requirements. The system automatically generates meta tags, titles, and descriptions optimized for the specific marketplace.

System Architecture

from openai import AsyncOpenAI
from dataclasses import dataclass
from typing import Optional
import asyncio

client = AsyncOpenAI()

@dataclass
class ProductData:
    name: str
    category: str
    brand: str
    sku: str
    attributes: dict          # {color: "red", size: "M", material: "cotton"}
    images: list[str] = None  # URL изображений
    price: float = None
    target_audience: str = ""

@dataclass
class GeneratedDescription:
    title: str              # SEO заголовок
    short_description: str  # 150–200 символов (превью на маркетплейсе)
    full_description: str   # HTML с форматированием
    bullet_points: list[str]  # 3–7 ключевых преимуществ
    seo_keywords: list[str]
    meta_description: str   # 160 символов для SEO

class ProductDescriptionGenerator:
    def __init__(self, platform: str = "general"):
        self.platform = platform
        self.platform_configs = {
            "wildberries": {"max_title": 60, "max_desc": 4000, "bullet_count": 5},
            "ozon": {"max_title": 100, "max_desc": 6000, "bullet_count": 7},
            "amazon": {"max_title": 200, "max_desc": 2000, "bullet_count": 5},
            "general": {"max_title": 80, "max_desc": 3000, "bullet_count": 5},
        }

    async def generate(
        self,
        product: ProductData,
        tone: str = "professional",
        language: str = "ru"
    ) -> GeneratedDescription:
        config = self.platform_configs.get(self.platform, self.platform_configs["general"])

        # Если есть изображения — используем GPT-4 Vision
        if product.images:
            return await self.generate_from_images(product, config, tone, language)
        else:
            return await self.generate_from_text(product, config, tone, language)

    async def generate_from_text(
        self,
        product: ProductData,
        config: dict,
        tone: str,
        language: str
    ) -> GeneratedDescription:
        attributes_str = "\n".join([f"- {k}: {v}" for k, v in product.attributes.items()])

        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Ты — эксперт по написанию продающих описаний для {self.platform}.
                Тон: {tone}.
                Язык: {language}.
                Ограничения: заголовок до {config['max_title']} символов,
                описание до {config['max_desc']} символов,
                {config['bullet_count']} буллетов преимуществ.

                Создай описание товара. Верни JSON с полями:
                title, short_description, full_description (HTML),
                bullet_points (массив), seo_keywords (массив), meta_description."""
            }, {
                "role": "user",
                "content": f"""Товар: {product.name}
                Бренд: {product.brand}
                Категория: {product.category}
                Характеристики:
                {attributes_str}
                ЦА: {product.target_audience or 'не указана'}"""
            }],
            response_format={"type": "json_object"}
        )

        data = json.loads(response.choices[0].message.content)
        return GeneratedDescription(**data)

    async def generate_from_images(
        self,
        product: ProductData,
        config: dict,
        tone: str,
        language: str
    ) -> GeneratedDescription:
        """Используем Vision для анализа фото товара"""
        import base64

        image_contents = [
            {"type": "image_url", "image_url": {"url": url}}
            for url in product.images[:3]  # Максимум 3 изображения
        ]

        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": f"""Проанализируй изображения товара и создай описание.
                    Платформа: {self.platform}. Тон: {tone}. Язык: {language}.
                    Дополнительные данные: Категория: {product.category}, Бренд: {product.brand}.
                    Верни JSON: title, short_description, full_description, bullet_points, seo_keywords, meta_description."""},
                ] + image_contents
            }],
            response_format={"type": "json_object"}
        )

        data = json.loads(response.choices[0].message.content)
        return GeneratedDescription(**data)

How the System Processes Catalogs from CSV/Excel

For loading products from CSV, we use batch processing: process_product_catalog reads the file, splits it into batches of 20 products, and generates descriptions in parallel via asyncio. Errors are handled with return_exceptions — a failure on one product does not stop the entire flow.

import pandas as pd
import asyncio

async def process_product_catalog(
    catalog_path: str,
    platform: str = "wildberries",
    batch_size: int = 20
) -> pd.DataFrame:
    df = pd.read_csv(catalog_path)
    generator = ProductDescriptionGenerator(platform=platform)
    results = []

    for i in range(0, len(df), batch_size):
        batch = df.iloc[i:i+batch_size]
        tasks = []

        for _, row in batch.iterrows():
            product = ProductData(
                name=row["name"],
                category=row["category"],
                brand=row.get("brand", ""),
                sku=row.get("sku", ""),
                attributes={k: row[k] for k in row.index if k not in ["name", "category", "brand", "sku"]}
            )
            tasks.append(generator.generate(product))

        batch_results = await asyncio.gather(*tasks, return_exceptions=True)
        for j, result in enumerate(batch_results):
            if isinstance(result, GeneratedDescription):
                row_data = batch.iloc[j].to_dict()
                row_data.update({
                    "generated_title": result.title,
                    "generated_short_desc": result.short_description,
                    "generated_full_desc": result.full_description,
                    "generated_bullets": " | ".join(result.bullet_points),
                    "seo_keywords": ", ".join(result.seo_keywords),
                })
                results.append(row_data)

    return pd.DataFrame(results)

Adaptation for Platforms

For each marketplace (Wildberries, Ozon, Amazon), we provide separate formatter classes. They handle character limits, structure requirements, and keywords. Example formatters:

class WildberriesFormatter:
    def format(self, desc: GeneratedDescription) -> dict:
        return {
            "наименование": desc.title[:60],
            "описание": desc.full_description[:4000],
            "характеристики": "\n".join(desc.bullet_points),
        }

class OzonFormatter:
    def format(self, desc: GeneratedDescription) -> dict:
        return {
            "name": desc.title[:100],
            "description": desc.full_description,
            "short_description": desc.short_description,
            "keywords": desc.seo_keywords,
        }

How Is SEO Optimization Ensured?

The system uses SEO rules for each platform: character limits, keywords, title structure. The prompt receives category, brand, and attributes, enabling relevant descriptions. Additionally, we apply few-shot and chain-of-thought techniques to improve quality. For Wildberries, the system automatically inserts popular queries into the title and meta description.

What Is Included in a Turnkey System Development?

1. Architecture and code — core generator, support for text and images (GPT-4 Vision), batch CSV/Excel processing.
2. Marketplace integration — adapters for Wildberries, Ozon, Amazon, direct API upload.
3. Documentation — API description, instructions for adding new platforms, model card.
4. Team training — 2 online sessions for configuration and operation.
5. 2-week post-launch support — bug fixes, prompt fine-tuning.

Timeline and How We Work

Cost is calculated individually after analyzing your catalog and integration requirements. Our team has specialized in AI solutions for e-commerce for over 5 years and has completed over 30 projects. We guarantee quality: each description undergoes validation against platform SEO rules.

Contact us to evaluate your project. Get a consultation on architecture and a preliminary timeline estimate.