# ProductPulse - AI Product Information (`1tm-solutions/productpulse---ai-product-information`) Actor

Get a product information like GTIN/EAN, attributes, categories, images from product brand and product name. Built-in AI copywriter generates professional descriptions in 6 styles and any language. Batch up to 100 products at $0.09 each with confidence scores for PIM automation.

- **URL**: https://apify.com/1tm-solutions/productpulse---ai-product-information.md
- **Developed by:** [1tm solutions GmbH](https://apify.com/1tm-solutions) (community)
- **Categories:** E-commerce, AI, Automation
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $90.00 / 1,000 product extractions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ProductPulse – AI Product Data Extraction & Copywriting

> **The fastest way to enrich your product catalog.** Extract GTINs, images, and product attributes – plus AI-generated descriptions like a professional copywriter.

- 📦 **Batch Processing** – Up to 100 products in a single run
- ✍️ **AI Copywriter** – Professional product descriptions in 6 styles, any language
- 🖼️ **Auto Image Discovery** – Official product photos extracted automatically
- 🧠 **AI-Powered Intelligence** – Fresh data from web sources, not stale databases
- 📊 **Confidence Scoring** – Know exactly what to trust vs. review

---

### ⚡ Power Features

#### Batch Processing (Up to 100 Products)

Process entire product lists in a single API call. Perfect for catalog enrichment at scale.

| Batch Size | Processing Time | Cost |
|------------|-----------------|------|
| 10 products | ~3-5 minutes | $0.90 |
| 50 products | ~5-8 minutes | $4.50 |
| 100 products | ~8-12 minutes | $9.00 |

**Benefits:**
- ⚡ Parallel processing architecture
- 📊 Partial success handling (one failure doesn't stop the batch)
- 💰 Same $0.09/product pricing at any volume

#### Auto Image Discovery

ProductPulse automatically finds official product images from authoritative web sources:

```json
"image_urls": [
  "https://static.nike.com/a/images/t_PDP_1728_v1/f_auto/air-max-90.jpg",
  "https://images.footlocker.com/nike-air-max-90-white.png"
]
````

- 🔍 Discovers images from manufacturer sites, retailers, and official sources
- 📸 Returns multiple image URLs when available
- ✅ Prioritizes high-resolution official product photos

***

### 🎯 The Problem We Solve

**Manual product research is a time sink:**

| Task | Manual Effort | With ProductPulse |
|------|--------------|---------------------|
| Find GTIN/EAN code | 5-15 minutes | ⚡ Automatic |
| Write product description | 10-20 minutes | ⚡ AI-generated in 5 languages |
| Categorize product | 3-5 minutes | ⚡ Auto-classified |
| Extract specifications | 10-15 minutes | ⚡ All attributes at once |
| **Total per product** | **30-55 minutes** | **⏱️ 60-120 seconds** |

**You have 500 new products from a supplier with only names and brands?**
That's 250+ hours of manual work. Or 15 hours with ProductPulse.

***

### 🔄 How Does AI Product Data Extraction Work?

```
┌─────────────────────────────────────────────────────────────────────┐
│                                                                     │
│   📝 INPUT              🤖 AI INTELLIGENCE            📊 OUTPUT    │
│                                                                     │
│  ┌───────────────┐     ┌─────────────────────┐    ┌─────────────┐ │
│  │ Product Name  │     │                     │    │ GTIN/EAN    │ │
│  │ Brand         │────▶│   Web Intelligence  │───▶│ Categories  │ │
│  │ Language      │     │   + AI Analysis     │    │ Images      │ │
│  └───────────────┘     │   + Verification    │    │ Descriptions│ │
│                        │                     │    │ + 20 more   │ │
│                        └─────────────────────┘    └─────────────┘ │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
```

**Three simple steps:**

1. **Send product name + brand** → Minimal input required
2. **AI gathers web intelligence** → Multi-source verification from authoritative sources
3. **Get structured data** → JSON with confidence scores for every attribute

***

### ❓ What Product Data Can You Extract Automatically?

| Category | Attributes | Confidence Scored |
|----------|------------|-------------------|
| 🏷️ **Identification** | GTIN/EAN barcode numbers | ✅ Yes |
| 📦 **Basic Data** | Brand, product name, category | ✅ Yes |
| 🎨 **Appearance** | Primary color, material | ✅ Yes |
| 📐 **Dimensions** | Size information | ✅ Yes |
| 🖼️ **Images** | Product image URLs from official sources | ✅ Yes |
| ✍️ **AI Copywriting** | Professional product descriptions in any language | ✅ Yes |
| 📊 **Quality Metrics** | Completeness %, review recommendations | ✅ Yes |
| 🔍 **Extended Attributes** | AI-discovered bonus attributes (technical specs, features) | ✅ Yes |

#### ✍️ AI Product Copywriter

ProductPulse doesn't just extract data – it **writes compelling product descriptions** like a professional copywriter:

- **6 Writing Styles**: Professional, Casual, Technical, Marketing, Luxurious, Minimalist
- **Any Language**: Generate descriptions in German, English, French, Spanish, Italian, or any other language
- **Product Highlights**: Emphasize specific selling points in the generated text
- **Brand Voice**: Consistent tone across your entire catalog

**Example output:**

```
"The Apple iPhone 15 Pro Max represents the pinnacle of smartphone engineering.
It features a robust yet lightweight aerospace-grade titanium design with a
textured matte-glass back. The device is powered by the A17 Pro chip, delivering
industry-leading performance and efficiency."
```

No more generic descriptions. No more copy-paste from competitors. Every product gets unique, SEO-friendly content.

**Every attribute includes a confidence score (0-1):**

- **0.85+** → Auto-accept into your PIM
- **0.70-0.85** → Quick human review recommended
- **Below 0.70** → Manual verification needed

***

### 💡 Real-World Use Cases

#### 📋 Scenario 1: PIM Onboarding Nightmare

> *"We just signed a new supplier. They sent us an Excel with 2,000 product names and nothing else. Launch is in 3 weeks."*

**Solution:** Batch process all products with ProductPulse. Get GTINs, categories, and descriptions for every item. Import directly to your PIM.

**Result:** 3 weeks of manual work → 3 days of automated processing.

***

#### 🛒 Scenario 2: E-commerce Catalog Gaps

> *"Our product listings are missing categories, colors, and materials. Google Shopping is rejecting our feed."*

**Solution:** Run existing products through ProductPulse to fill missing attributes. Confidence scores tell you what's reliable.

**Result:** Shopping feed acceptance rate: 45% → 94%.

***

#### 🏭 Scenario 3: Supplier Data Chaos

> *"Every supplier uses different naming conventions. We need standardized data for our ERP."*

**Solution:** Use ProductPulse to normalize all supplier data to your schema. AI extracts consistent attributes regardless of input format.

**Result:** One unified product database from 15 different supplier formats.

***

### 🚀 Quick Start – How to Extract Product Data

#### Input (Minimal Required)

```json
{
  "productName": "Air Max 90",
  "brand": "Nike",
  "language": "de"
}
```

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `productName` | string | ✅ Yes | The product name to research |
| `brand` | string | ✅ Yes | The product brand or manufacturer |
| `language` | string | ❌ No | Output language: `de`, `en`, `fr`, `es`, `it` (default: `de`) |

#### Output (The Money Shot)

```json
{
  "products_attributes": {
    "gtin": "0195239925344",
    "ean": "195239925344",
    "brand": "Nike",
    "product_name": "Nike Air Max 90",
    "category": "clothing",
    "primary_color": "White/Black",
    "material": "leather",
    "size": "EU 36-49",
    "product_description": "Der Nike Air Max 90 ist ein legendärer Sneaker...",
    "image_urls": [
      "https://static.nike.com/a/images/t_PDP_1728_v1/f_auto/air-max-90.jpg"
    ],
    "extended_attributes": {
      "features_cushioning": "Air Max visible air unit",
      "features_closure": "Lace-up"
    }
  },
  "confidence": 0.92,
  "sources": [
    { "url": "https://www.nike.com/...", "title": "Nike Official" }
  ],
  "metadata": {
    "processingTimeMs": 45000,
    "textStyleUsed": "Professional"
  },
  "quality": {
    "completeness": 0.85,
    "manualReviewRecommended": false,
    "lowConfidenceAttributes": []
  }
}
```

***

### 📦 Batch Processing

Process multiple products in a single run for maximum efficiency.

#### Batch Input

```json
{
  "products": [
    { "productName": "Air Max 90", "brand": "Nike" },
    { "productName": "iPhone 15 Pro", "brand": "Apple" },
    { "productName": "Dyson V15", "brand": "Dyson", "gtin": "5025155080511" }
  ],
  "language": "de",
  "ai_text_style": "Professional"
}
```

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `products` | array | ✅ Yes | Array of products (max 100) |
| `products[].productName` | string | ✅ Yes | Product name to research |
| `products[].brand` | string | ✅ Yes | Product brand |
| `products[].gtin` | string | ❌ No | Optional GTIN for this product |
| `products[].ai_product_highlight` | string | ❌ No | Optional highlight for this product |
| `language` | string | ❌ No | Shared language for all products |
| `ai_text_style` | string | ❌ No | Shared text style for all products |

#### Batch Output

Each successful product is pushed as an individual dataset item. The key-value store contains a summary:

```json
{
  "summary": {
    "total": 10,
    "successful": 9,
    "failed": 1,
    "successRate": 90
  },
  "results": [
    { "index": 0, "productName": "Air Max 90", "brand": "Nike", "success": true, "confidence": 0.92 },
    { "index": 1, "productName": "iPhone 15 Pro", "brand": "Apple", "success": true, "confidence": 0.95 },
    { "index": 2, "productName": "Unknown Product", "brand": "Unknown", "success": false, "error": "Timeout" }
  ]
}
```

#### Batch Pricing

**Same $0.09 per product** – no volume penalty or discount.

| Batch Size | Price | Processing Time |
|------------|-------|-----------------|
| 10 | $0.90 | ~3-5 minutes |
| 50 | $4.50 | ~5-8 minutes |
| 100 | $9.00 | ~8-12 minutes |

#### Batch Best Practices

1. **Optimal batch size**: 10-50 products for best efficiency
2. **Error handling**: Check `summary.failed` count and individual results
3. **Progress monitoring**: Watch Actor status message for real-time progress
4. **Rate limits**: Larger batches may hit API rate limits; results still complete via retry

***

### ⚡ API Integration Examples

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~productpulse/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productName": "Air Max 90", "brand": "Nike", "language": "de"}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_USERNAME/productpulse").call(
    run_input={
        "productName": "Air Max 90",
        "brand": "Nike",
        "language": "de"
    }
)

## Get results
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0])
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('YOUR_USERNAME/productpulse').call({
  productName: 'Air Max 90',
  brand: 'Nike',
  language: 'de',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Batch Processing (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_USERNAME/productpulse").call(
    run_input={
        "products": [
            {"productName": "Air Max 90", "brand": "Nike"},
            {"productName": "iPhone 15 Pro", "brand": "Apple"},
            {"productName": "Dyson V15", "brand": "Dyson"}
        ],
        "language": "de"
    }
)

## Get all results
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Processed {len(items)} products")

## Check summary in key-value store
kvStore = client.key_value_store(run["defaultKeyValueStoreId"])
summary = kvStore.get_record("OUTPUT")
print(f"Success rate: {summary['value']['summary']['successRate']}%")
```

#### Zapier / Make / n8n

Use the official **Apify integration** to trigger ProductPulse from your automation workflows. Results flow automatically to subsequent steps.

***

### 📊 How Does ProductPulse Compare to Alternatives?

| Feature | ProductPulse | Manual Research | GTIN Databases | Traditional Scrapers |
|---------|---------------|-----------------|----------------|---------------------|
| **Time per product** | 60-120 sec | 30-55 min | Instant lookup | 5-30 sec |
| **GTIN/EAN included** | ✅ Yes | ✅ Manual | ✅ Yes | ❌ Rarely |
| **Product images** | ✅ Auto-discovered | ✅ Manual | ❌ No | ⚠️ Sometimes |
| **Product descriptions** | ✅ AI-generated | ✅ Manual | ❌ No | ❌ No |
| **Multi-language** | ✅ 5 languages | ❌ One at a time | ❌ No | ❌ No |
| **Confidence scores** | ✅ Yes | ❌ No | ❌ No | ❌ No |
| **Legal/Ethical** | ✅ Legitimate APIs | ✅ Yes | ✅ Yes | ⚠️ ToS risks |
| **Adapts to changes** | ✅ Real-time web | ❌ No | ⚠️ Database lag | ⚠️ Breaks often |
| **Cost per product** | $0.09 | ~$5-15 (labor) | $0.01-0.05 | $0.001-0.01 |
| **Data completeness** | 85%+ | Variable | IDs only | Variable |

**Why AI-powered extraction beats traditional approaches:**

- 🔄 **No maintenance** – AI adapts to website changes
- ✅ **No ToS violations** – Uses legitimate API-based data access
- 📊 **Quality signals** – Know what to trust with confidence scores
- 🌍 **Multi-source verification** – Cross-references multiple sources

***

### 💰 How Much Does AI Product Data Extraction Cost?

#### Pricing: $0.09 per Product (All-Inclusive)

**No hidden fees. No separate compute charges.** You pay exactly $0.09 per successful product extraction.

| What's Included in $0.09 | |
|--------------------------|---|
| AI processing & analysis | ✅ Included |
| Web intelligence gathering | ✅ Included |
| Apify compute resources | ✅ Included |
| Storage & dataset operations | ✅ Included |
| Proxy & network costs | ✅ Included |

#### What You Get

| Feature | Included |
|---------|----------|
| Full attribute extraction (GTIN, category, colors, etc.) | ✅ |
| Product image URLs (auto-discovered) | ✅ |
| AI-generated descriptions | ✅ |
| 5 output languages | ✅ |
| 6 text style options | ✅ |
| Custom attributes | ✅ |
| Extended AI-discovered attributes | ✅ |
| Confidence scores | ✅ |
| Source URLs | ✅ |
| Quality metrics | ✅ |

#### Volume Examples

| Products | Total Cost | Cost Per Product | Time Saved vs Manual |
|----------|-----------|------------------|---------------------|
| 1 | $0.09 | $0.09 | ~35 minutes |
| 10 | $0.90 | $0.09 | ~6 hours |
| 100 | $9.00 | $0.09 | ~60 hours |
| 1,000 | $90.00 | $0.09 | ~600 hours |
| 10,000 | $900.00 | $0.09 | ~6,000 hours |

#### Pricing Transparency

ProductPulse uses Apify's **Pay-Per-Event (PPE)** pricing model:

- **You pay**: $0.09 per product extraction event
- **No additional charges**: Compute units, storage, and AI costs are absorbed by us
- **Predictable costs**: Know exactly what you'll pay before running
- **Failed extractions**: Not charged (only successful results trigger billing)

**💡 New Apify accounts include free credits to test the Actor.**

***

### 🌍 Supported Languages

| Code | Language | Description Quality |
|------|----------|---------------------|
| `de` | German | ⭐⭐⭐⭐⭐ Native quality |
| `en` | English | ⭐⭐⭐⭐⭐ Native quality |
| `fr` | French | ⭐⭐⭐⭐ High quality |
| `es` | Spanish | ⭐⭐⭐⭐ High quality |
| `it` | Italian | ⭐⭐⭐⭐ High quality |

***

### 🔧 Troubleshooting

#### "Product not found" or low completeness score

**Causes:**

- Very niche or new product with limited web presence
- Misspelled product name or brand
- Regional product not available internationally

**Solutions:**

1. Verify the exact product name from manufacturer website
2. Try alternative product name variations
3. Check if product exists in major retailers

#### Low GTIN confidence score

**Causes:**

- Multiple product variants (colors/sizes) with different GTINs
- Product is very new or discontinued
- Limited authoritative sources

**Solutions:**

1. Include variant details in product name (e.g., "Air Max 90 White Size 42")
2. Use the extracted sources to manually verify
3. Cross-reference with manufacturer database

#### Processing timeout

**Causes:**

- Complex product requiring extensive research
- Temporary API delays

**Solutions:**

1. Retry the extraction
2. If persistent, contact support

***

### ❓ Frequently Asked Questions

#### Why does extraction take 60-120 seconds?

**Unlike simple database lookups or scrapers, ProductPulse performs deep AI research:**

1. Gathers data from multiple authoritative sources
2. Analyzes web pages and product information
3. Cross-references information across sources
4. Generates confidence scores
5. Creates multi-language descriptions

This delivers verified, high-quality data – not just cached information.

#### Is this legal? What about website terms of service?

**Yes, ProductPulse is fully legal and ethical:**

- ✅ **No scraping** – Uses legitimate API-based data access
- ✅ **No ToS violations** – AI researches publicly available information
- ✅ **GDPR compliant** – No personal data extracted or stored
- ✅ **Ethical AI** – Following industry best practices for responsible AI usage

#### How accurate are GTIN/EAN codes?

| Product Type | Expected Accuracy |
|--------------|-------------------|
| Popular brands (Nike, Apple, Samsung) | ~95% |
| Mid-tier brands | ~85% |
| Niche/local products | ~70% |
| Very new products | ~60% |

The confidence score tells you how reliable each GTIN is. Trust high scores, verify low ones.

#### Can I use custom attributes?

**Yes!** Define your own attribute schema in the input. The AI will extract exactly what you need. Examples:

- Technical specifications (voltage, wattage, capacity)
- Fashion attributes (sleeve length, neckline, fit)
- Food attributes (ingredients, allergens, nutrition)

#### What if the AI gets something wrong?

Every attribute includes a confidence score. Low confidence = automatic review flag. Use the `quality.manualReviewRecommended` field to identify items needing human verification.

#### Can I process multiple products at once?

**Yes!** ProductPulse supports batch processing up to 100 products per run.

```json
{
  "products": [
    { "productName": "Air Max 90", "brand": "Nike" },
    { "productName": "iPhone 15 Pro", "brand": "Apple" },
    { "productName": "Dyson V15", "brand": "Dyson" }
  ],
  "language": "de"
}
```

**Batch benefits:**

- ⚡ Parallel processing (~3-8 minutes for 50 products)
- 💰 Same $0.09/product pricing (no volume penalty)
- 📊 Partial success handling (one failure doesn't stop the batch)
- 📈 Progress tracking via status messages

***

### 📋 Current Limitations & Roadmap

#### Known Limitations

| Limitation | Workaround |
|------------|------------|
| 60-120s processing time per product | Required for quality research; batch mode processes in parallel |
| Max 100 products per batch | Run multiple batches for larger datasets |
| GTIN accuracy varies | Use confidence scores to filter |

#### Upcoming Features

- \[x] 📦 ~~Batch processing~~ → **Shipped in v1.3.0!** Up to 100 products per run
- \[x] 🖼️ ~~Image-based product extraction~~ → **Shipped in v1.2.1!** `image_urls` now included
- \[ ] 🔔 Webhook notifications
- \[ ] 📊 Custom attribute schemas
- \[ ] 🔗 Direct PIM integrations

***

### 🆘 Support

Having issues? Need a feature?

- 📝 **Issues tab** on this Actor page – Bug reports, feature requests
- 💬 **Apify Discord** – Community support
- 📧 **Contact developer** – Through Apify platform

***

### 📝 Changelog

#### v1.3.0 (January 2026)

- 📦 **Batch processing**: Process up to 100 products in a single run
- ⚡ Parallel processing architecture (~3-8 minutes for 50 products)
- 📊 Partial success handling with detailed error reporting
- 📈 Real-time progress tracking via status messages
- 🔄 Backwards compatible (single product mode unchanged)

#### v1.2.1 (January 2026)

- 🖼️ **Image URL discovery**: Automatically finds product images from web sources
- 📸 Returns `image_urls` array with official product photos

#### v1.2.0 (January 2026)

- 💰 **Pay-per-event pricing**: $0.09 per product extraction
- 🔗 Apify billing system integration
- 📊 Transparent, predictable pricing

#### v1.1.0 (January 2026)

- 🔍 Extended attributes (AI-discovered bonus data)
- ⚙️ Custom attribute extraction
- ✍️ 6 text style options for descriptions
- ⭐ Product highlights feature
- 📦 New `products_attributes` output structure

#### v1.0.0 (January 2026)

- 🚀 Initial release
- 🤖 AI-powered product extraction engine
- 🌍 5 output languages
- 📊 Confidence scoring per attribute
- ✅ Quality assessment metrics

***

<p align="center">
  <strong>Built by 1TM on Apify</strong><br>
  <em>AI-powered product data extraction at scale</em>
</p>

# Actor input Schema

## `productName` (type: `string`):

Single product mode: The product name to research (e.g., 'Air Max 90'). Leave empty when using batch mode.

## `brand` (type: `string`):

Single product mode: The product brand (e.g., 'Nike'). Leave empty when using batch mode.

## `products` (type: `array`):

Batch mode: Array of products to process (max 100). Each product requires productName and brand. When provided, single product fields are ignored.

## `language` (type: `string`):

Language for generated descriptions and text content

## `gtin` (type: `string`):

Optional GTIN/EAN barcode (8, 12, 13, or 14 digits). If provided, improves accuracy and helps validate product identity.

## `ai_text_style` (type: `string`):

Writing style for the generated product description

## `ai_product_highlight` (type: `string`):

Special selling point or feature to emphasize in the description (e.g., 'Iconic streetwear design since 1990')

## `custom_attributes` (type: `object`):

Key-value pairs defining custom attributes to extract. Key is attribute name, value describes what to extract (e.g., {"target\_audience": "The intended customer demographic", "sustainability": "Environmental credentials if available"})

## Actor input object example

```json
{
  "productName": "Air Max 90",
  "brand": "Nike",
  "products": [],
  "language": "de",
  "ai_text_style": "Professional",
  "custom_attributes": {}
}
```

# Actor output Schema

## `productData` (type: `string`):

Complete extraction results including attributes, confidence scores, and sources

## `summary` (type: `string`):

Quick access to the latest extraction output

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productName": "Air Max 90",
    "brand": "Nike",
    "products": [],
    "custom_attributes": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("1tm-solutions/productpulse---ai-product-information").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "productName": "Air Max 90",
    "brand": "Nike",
    "products": [],
    "custom_attributes": {},
}

# Run the Actor and wait for it to finish
run = client.actor("1tm-solutions/productpulse---ai-product-information").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productName": "Air Max 90",
  "brand": "Nike",
  "products": [],
  "custom_attributes": {}
}' |
apify call 1tm-solutions/productpulse---ai-product-information --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=1tm-solutions/productpulse---ai-product-information",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProductPulse - AI Product Information",
        "description": "Get a product information like GTIN/EAN, attributes, categories, images from product brand and product name. Built-in AI copywriter generates professional descriptions in 6 styles and any language. Batch up to 100 products at $0.09 each with confidence scores for PIM automation.",
        "version": "1.3",
        "x-build-id": "y3jpeFQAgbeXZfVq2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/1tm-solutions~productpulse---ai-product-information/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-1tm-solutions-productpulse---ai-product-information",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/1tm-solutions~productpulse---ai-product-information/runs": {
            "post": {
                "operationId": "runs-sync-1tm-solutions-productpulse---ai-product-information",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/1tm-solutions~productpulse---ai-product-information/run-sync": {
            "post": {
                "operationId": "run-sync-1tm-solutions-productpulse---ai-product-information",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "productName": {
                        "title": "Product Name",
                        "type": "string",
                        "description": "Single product mode: The product name to research (e.g., 'Air Max 90'). Leave empty when using batch mode."
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Single product mode: The product brand (e.g., 'Nike'). Leave empty when using batch mode."
                    },
                    "products": {
                        "title": "Products (Batch Mode)",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Batch mode: Array of products to process (max 100). Each product requires productName and brand. When provided, single product fields are ignored.",
                        "items": {
                            "type": "object",
                            "required": [
                                "productName",
                                "brand"
                            ],
                            "properties": {
                                "productName": {
                                    "title": "Product Name",
                                    "type": "string",
                                    "description": "The product name to research"
                                },
                                "brand": {
                                    "title": "Brand",
                                    "type": "string",
                                    "description": "The product brand or manufacturer"
                                },
                                "gtin": {
                                    "title": "GTIN / EAN",
                                    "type": "string",
                                    "description": "Optional GTIN/EAN barcode (8-14 digits)",
                                    "pattern": "^[0-9]{8,14}$"
                                },
                                "ai_product_highlight": {
                                    "title": "Product Highlight",
                                    "type": "string",
                                    "description": "Optional highlight for this specific product"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Output Language",
                        "enum": [
                            "de",
                            "en",
                            "fr",
                            "es",
                            "it"
                        ],
                        "type": "string",
                        "description": "Language for generated descriptions and text content",
                        "default": "de"
                    },
                    "gtin": {
                        "title": "GTIN / EAN",
                        "pattern": "^[0-9]{8,14}$",
                        "type": "string",
                        "description": "Optional GTIN/EAN barcode (8, 12, 13, or 14 digits). If provided, improves accuracy and helps validate product identity."
                    },
                    "ai_text_style": {
                        "title": "AI Text Style",
                        "enum": [
                            "Professional",
                            "Casual",
                            "Technical",
                            "Marketing",
                            "Luxurious",
                            "Minimalist"
                        ],
                        "type": "string",
                        "description": "Writing style for the generated product description",
                        "default": "Professional"
                    },
                    "ai_product_highlight": {
                        "title": "Product Highlight",
                        "type": "string",
                        "description": "Special selling point or feature to emphasize in the description (e.g., 'Iconic streetwear design since 1990')"
                    },
                    "custom_attributes": {
                        "title": "Custom Attributes",
                        "type": "object",
                        "description": "Key-value pairs defining custom attributes to extract. Key is attribute name, value describes what to extract (e.g., {\"target_audience\": \"The intended customer demographic\", \"sustainability\": \"Environmental credentials if available\"})"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```