# Investigador de Contenido para Shorts (TikTok/Reels/YouTube) (`lasting_gas/my-actor`) Actor

Genera contenido listo para videos cortos (TikTok, Reels, YouTube Shorts) a partir de un tema: busca informacion confiable en la web y usa IA (Gemini) para crear titulo, resumen, datos clave, curiosidades y fuentes.

- **URL**: https://apify.com/lasting\_gas/my-actor.md
- **Developed by:** [JESUS BARBOZA](https://apify.com/lasting_gas) (community)
- **Categories:** AI, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

## Investigador de Contenido para Shorts (TikTok / Reels / YouTube Shorts)

Actor de Apify que recibe un **tema** y genera contenido estructurado y
verificado, listo para guionizar videos cortos: titulo, resumen, 5 datos
importantes, 3 curiosidades y las fuentes utilizadas.

### Como funciona

1. Busca el tema en DuckDuckGo.
2. Extrae el contenido de las paginas mas relevantes (excluyendo redes
   sociales y sitios de video, que no aportan texto util).
3. Envia ese contenido a un modelo de Google Gemini (con nivel gratuito),
   que sintetiza la informacion en el formato solicitado, sin inventar
   datos fuera de las fuentes.
4. Guarda el resultado en el Dataset del Actor y en el registro `OUTPUT`.

### Input

| Campo          | Tipo    | Obligatorio | Descripcion                                                |
|----------------|---------|:-----------:|-------------------------------------------------------------|
| `topic`        | string  | si          | Tema a investigar (ej. `"Efecto Mandela"`).                 |
| `maxSources`   | integer | no          | Maximo de fuentes a analizar (por defecto 5).               |
| `model`        | string  | no          | Modelo de Gemini a usar (por defecto `gemini-2.5-flash`).   |
| `geminiApiKey` | string  | ver nota    | Clave de Gemini (o definila como variable de entorno `GEMINI_API_KEY`). |

Ejemplo:

```json
{
  "topic": "Efecto Mandela"
}
````

> **Importante:** este Actor necesita una clave de API de Google Gemini
> (gratuita) para generar el contenido. Puedes crear una en
> https://aistudio.google.com/apikey con tu cuenta de Google, sin costo,
> dentro de los limites del nivel gratuito. Se recomienda configurarla como
> variable de entorno `GEMINI_API_KEY` en la pestana "Environment variables"
> del Actor (no en el input), para que no quede visible en las corridas.

### Output

El Actor guarda un registro en el Dataset y en el key-value store (`OUTPUT`)
con este formato:

```json
{
  "topic": "Efecto Mandela",
  "title": "...",
  "summary": "...",
  "facts": ["...", "...", "...", "...", "..."],
  "curiosities": ["...", "...", "..."],
  "sources": ["https://...", "https://..."]
}
```

### Buenas practicas aplicadas

- Uso de `Actor.init()` / `Actor.exit()` y manejo de errores con `Actor.fail()`.
- Validacion estricta del input antes de ejecutar cualquier logica.
- Uso de `CheerioCrawler` (Crawlee) para scraping liviano y eficiente.
- Limite de solicitudes (`maxRequestsPerCrawl`) para controlar el consumo.
- Exclusion de dominios que no aportan texto util (redes sociales/video).
- La clave de API se puede definir como variable de entorno para mayor seguridad.
- Uso del modo de salida JSON nativo de Gemini (`responseMimeType: "application/json"`).
- Salida validada y normalizada exactamente al esquema solicitado.

### Ejecutar localmente

```bash
npm install
export GEMINI_API_KEY=tu_clave_aqui
npm start
```

# Actor input Schema

## `topic` (type: `string`):

Tema sobre el que se buscará información (ej: 'Efecto Mandela').

## `maxSources` (type: `integer`):

Cantidad máxima de páginas web que se analizarán como fuentes.

## `model` (type: `string`):

Modelo de Google Gemini usado para generar el contenido estructurado.

## `geminiApiKey` (type: `string`):

Tu clave gratuita de Google AI Studio (aistudio.google.com/apikey). También puedes definirla como variable de entorno GEMINI\_API\_KEY en la configuración del Actor (recomendado).

## Actor input object example

```json
{
  "topic": "Efecto Mandela",
  "maxSources": 5,
  "model": "gemini-2.5-flash"
}
```

# Actor output Schema

## `results` (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 = {
    "topic": "Efecto Mandela"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lasting_gas/my-actor").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 = { "topic": "Efecto Mandela" }

# Run the Actor and wait for it to finish
run = client.actor("lasting_gas/my-actor").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 '{
  "topic": "Efecto Mandela"
}' |
apify call lasting_gas/my-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lasting_gas/my-actor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Investigador de Contenido para Shorts (TikTok/Reels/YouTube)",
        "description": "Genera contenido listo para videos cortos (TikTok, Reels, YouTube Shorts) a partir de un tema: busca informacion confiable en la web y usa IA (Gemini) para crear titulo, resumen, datos clave, curiosidades y fuentes.",
        "version": "0.0",
        "x-build-id": "4EIzRriW396jCLySc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lasting_gas~my-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lasting_gas-my-actor",
                "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/lasting_gas~my-actor/runs": {
            "post": {
                "operationId": "runs-sync-lasting_gas-my-actor",
                "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/lasting_gas~my-actor/run-sync": {
            "post": {
                "operationId": "run-sync-lasting_gas-my-actor",
                "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",
                "required": [
                    "topic"
                ],
                "properties": {
                    "topic": {
                        "title": "Tema",
                        "type": "string",
                        "description": "Tema sobre el que se buscará información (ej: 'Efecto Mandela')."
                    },
                    "maxSources": {
                        "title": "Número máximo de fuentes",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Cantidad máxima de páginas web que se analizarán como fuentes.",
                        "default": 5
                    },
                    "model": {
                        "title": "Modelo de Gemini",
                        "type": "string",
                        "description": "Modelo de Google Gemini usado para generar el contenido estructurado.",
                        "default": "gemini-2.5-flash"
                    },
                    "geminiApiKey": {
                        "title": "Clave de API de Gemini",
                        "type": "string",
                        "description": "Tu clave gratuita de Google AI Studio (aistudio.google.com/apikey). También puedes definirla como variable de entorno GEMINI_API_KEY en la configuración del Actor (recomendado)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
