# AI Product Description Generator (any shop URL) (`flets_sv/ficha-producto`) Actor

Turn any product page URL or photo into an SEO-ready listing with AI: title, description, attributes, price and images. Export to Shopify and WooCommerce.

- **URL**: https://apify.com/flets_sv/ficha-producto.md
- **Developed by:** [FlEtsv](https://apify.com/flets_sv) (community)
- **Categories:** E-commerce, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 ficha generadas

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Product Description Generator (any shop URL)

Turn any e-commerce product page URL into a ready-to-publish product listing with AI: title, description, attributes, category, price and images, in any language, with export formats for Shopify, WooCommerce and Wallapop. *Versión en español más abajo.*

***

### Use cases

- Generate SEO product descriptions in bulk from any shop product URL
- Migrate or enrich catalogues for Shopify, WooCommerce and marketplaces
- Create consistent titles, bullet points and meta descriptions in several languages
- Refresh thin product pages to improve organic traffic

### English

#### What does it do?

Give it product page URLs (or product photos). For each one the Actor reads the page, extracts the facts (price, images, specs) and uses an AI model to write a clean listing in the language you choose. One input URL produces one dataset item.

Use cases:

- **Catalog migration and enrichment:** rewrite supplier descriptions into unique SEO-friendly text.
- **Dropshipping and marketplaces:** create listings for Shopify, WooCommerce or Wallapop in bulk.
- **Multilingual stores:** generate the same product in several languages (`idioma`).
- **Image to listing:** build a listing from a product photo.

#### Input

An empty input `{}` runs a demo with two sample books from books.toscrape.com.

| Field | Description |
|---|---|
| `productos` | Product page or image URLs (one listing per URL). |
| `idioma` | Language of the generated listing (default `es`; use `en`, `fr`, `de`...). |
| `formatosSalida` | Export formats: `shopify`, `woocommerce`, `wallapop`. |
| `maxProductos` | Max products per run (default `2`). |

```json
{
  "productos": ["https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"],
  "idioma": "en",
  "formatosSalida": ["shopify"],
  "maxProductos": 10
}
```

#### Output

Real item from a run with `{}`:

```json
{
  "ok": true,
  "titulo": "A Light in the Attic",
  "descripcion": "Colección clásica de poesía y dibujos de Shel Silverstein que celebra su 20.º aniversario con una edición especial...",
  "atributos": [
    { "clave": "Autor", "valor": "Shel Silverstein" },
    { "clave": "Edición", "valor": "20th Anniversary" }
  ],
  "categoria": "Poetry",
  "precio": { "moneda": "GBP", "valor": 51.77 },
  "idioma": "es",
  "fuente": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
  "imagenes": ["https://books.toscrape.com/media/cache/fe/72/fe72f0532301ec28892ae79a629a293c.jpg"],
  "generadoEn": "2026-10-31T18:47:32.846Z",
  "avisoIA": "Contenido generado con IA. Revisa y verifica la ficha antes de publicarla.",
  "formatos": {}
}
```

#### Pricing (pay per event)

| Event | Price | Per 1,000 |
|---|---|---|
| Listing generated (`ficha-generada`) | $0.02 | $20.00 |

You are charged only for valid listings. No AI key needed: the AI cost is included.

#### Integrations (Make, Zapier, Google Sheets)

- **Make**: add the Apify module "Run an Actor" (Actor `Flets_sv/ficha-producto`), paste the input JSON, chain "Get Dataset Items" and map the fields to Google Sheets, Slack, Airtable or your CRM.
- **Zapier**: the Apify app offers "Run Actor" and "Fetch Dataset Items". Add a Schedule trigger and send each row to Gmail, Slack or Notion.
- **Google Sheets**: enable the official Google Sheets integration in the Actor's Integrations tab to append every run to a sheet, or call `https://api.apify.com/v2/acts/Flets_sv~ficha-producto/run-sync-get-dataset-items?format=csv` with POST and your input from Apps Script (`UrlFetchApp`).
- **API and webhooks**: start the Actor from the REST API, use Schedules for recurring runs and add a webhook to notify your system when a run finishes.

Input to paste into Make or Zapier:

```json
{"productos":["https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"],"idioma":"es","maxProductos":2}
```

#### FAQ

**Is it legal?** The Actor fetches the public URLs you provide, like a browser would, and does not bypass logins or protections. You are responsible for having the right to reuse the content and images of the pages you submit (copyright, site terms). The generated text is a new description; always review it.

**Can the AI invent details?** It can. Every item carries `avisoIA`; review before publishing.

**Which shops work?** Pages that expose product data in HTML or structured data. Pages that require login or heavy JavaScript rendering may return `ok: false` with an error message.

**Are my images stored?** No. Uploaded images are only processed to write the listing and are not stored; only the structured result stays in the run dataset.

**Which languages?** Any language the AI model supports; set `idioma`.

#### Integrations

- **API / SDKs:** `POST https://api.apify.com/v2/acts/flets_sv~ficha-producto/runs`, JavaScript and Python clients.
- **Make, Zapier, n8n, Google Sheets:** feed a sheet of URLs and write listings back.
- **MCP / AI agents:** expose it to Claude or any MCP client through `https://mcp.apify.com`.
- Export results as JSON, CSV or Excel.

#### Data source

The pages you supply. No third-party database is used.

***

### Español

#### ¿Qué hace?

Convierte URLs de páginas de producto (o fotos) en **fichas de producto listas para publicar** con IA: título, descripción, atributos, categoría, precio e imágenes, en el idioma que elijas y con formatos de exportación para Shopify, WooCommerce y Wallapop. Un elemento de entrada produce un ítem del dataset.

#### Input

Con `{}` ejecuta una demo con dos libros de books.toscrape.com. Campos: `productos` (URLs), `idioma` (por defecto `es`), `formatosSalida` (`shopify`, `woocommerce`, `wallapop`), `maxProductos` (por defecto 2).

#### Output

Ver el ejemplo real de la sección inglesa.

#### Precios (pago por evento)

| Evento | Precio | Por 1.000 |
|---|---|---|
| Ficha generada (`ficha-generada`) | 0,02 $ | 20,00 $ |

Solo se cobran las fichas válidas. El coste de la IA está incluido.

#### Integraciones (Make, Zapier, Google Sheets)

- **Make**: añade el módulo de Apify «Run an Actor» (Actor `Flets_sv/ficha-producto`), pega el input JSON y encadena «Get Dataset Items»; después mapea los campos a Google Sheets, Slack, Airtable o tu CRM.
- **Zapier**: la app de Apify ofrece «Run Actor» y «Fetch Dataset Items». Ponle un disparador de horario y envía cada fila a Gmail, Slack o Notion.
- **Google Sheets**: en la pestaña Integrations del Actor activa la integración oficial con Google Sheets para añadir cada ejecución a una hoja, o llama desde Apps Script (`UrlFetchApp`) a `https://api.apify.com/v2/acts/Flets_sv~ficha-producto/run-sync-get-dataset-items?format=csv` con POST y tu input.
- **API y webhooks**: lanza el Actor por API REST, programa ejecuciones (Schedules) y avisa a tu sistema con un webhook al terminar.

Ejemplo de input para pegar en Make o Zapier:

```json
{"productos":["https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"],"idioma":"es","maxProductos":2}
```

#### Preguntas frecuentes

**¿Es legal?** El Actor lee las URLs públicas que tú indicas, sin saltarse accesos ni protecciones. Eres responsable de tener derecho a reutilizar textos e imágenes de esas páginas. La descripción generada es texto nuevo; revísala siempre.

**¿Se guardan mis imágenes? (Privacidad)** No se guardan: solo se procesan para generar la ficha; en el dataset queda únicamente el resultado estructurado.

**¿La IA puede inventar datos?** Sí. Cada ítem lleva `avisoIA`: revisa antes de publicar.

#### Integración

API de Apify, Make, Zapier, n8n, Google Sheets y agentes de IA vía MCP (`https://mcp.apify.com`).

#### Fuente

Las páginas que proporcionas. No usa bases de datos de terceros.

### Ejemplos de uso / Usage examples

#### Example output (real run, 2026-11-05)

First rows returned by a real run of this Actor on 2026-11-05 (shortened columns, values truncated):

| titulo | categoria | precio | idioma | fuente |
|---|---|---|---|---|
| A Light in the Attic | Poetry | moneda: GBP, valor: 51.77 | en | https://books.toscrape.com/catalogue/a-light-in-the-attic... |

#### Copy-paste inputs

**1. One product page to a Shopify-ready listing**

```json
{
  "productos": [
    "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
  ],
  "idioma": "en",
  "formatosSalida": [
    "shopify"
  ],
  "maxProductos": 10
}
```

**2. Several shop URLs in Spanish, WooCommerce format**

```json
{
  "productos": [
    "https://example-shop.com/product/1",
    "https://example-shop.com/product/2"
  ],
  "idioma": "es",
  "formatosSalida": [
    "woocommerce"
  ],
  "maxProductos": 20
}
```

#### Call it from your code (Apify API)

```bash
curl -X POST "https://api.apify.com/v2/acts/Flets_sv~ficha-producto/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productos": ["https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"], "idioma": "en", "formatosSalida": ["shopify"], "maxProductos": 10}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("Flets_sv/ficha-producto").call(run_input={"productos": ["https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"], "idioma": "en", "formatosSalida": ["shopify"], "maxProductos": 10})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

No code? Use the Apify modules for **Make** and **Zapier** (run the Actor, then fetch dataset items), or the **Google Sheets** integration in the Actor's Integrations tab to append each run to a sheet.

# Actor input Schema

## `productos` (type: `array`):

URLs de paginas de producto o de imagenes; se genera una ficha por elemento.

## `idioma` (type: `string`):

Idioma en el que se generara la ficha.

## `formatosSalida` (type: `array`):

Plataformas a las que se exportara la ficha.

## `maxProductos` (type: `integer`):

Limite de productos que se procesaran en la ejecucion.

## Actor input object example

```json
{
  "productos": [
    "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"
  ],
  "idioma": "es",
  "formatosSalida": [],
  "maxProductos": 2
}
```

# Actor output Schema

## `fichas` (type: `string`):

No description

# 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 = {
    "productos": [
        "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
        "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flets_sv/ficha-producto").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 = { "productos": [
        "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
        "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("flets_sv/ficha-producto").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "productos": [
    "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"
  ]
}' |
apify call flets_sv/ficha-producto --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flets_sv/ficha-producto"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bD5HBFNzYczpsnjiI/builds/NGCmd9nOgKeUJOy9q/openapi.json