# \[DEPRECATED] social-media-content-generator - DO NOT USE (`viralanalyzer/social-media-content-generator`) Actor

DEPRECATED ACTOR: This actor relies on external HuggingFace Spaces which are unstable (sleeping or deleted Spaces cause 100% failure rate). It will be replaced by a more reliable version. Do not run.

- **URL**: https://apify.com/viralanalyzer/social-media-content-generator.md
- **Developed by:** [viralanalyzer](https://apify.com/viralanalyzer) (community)
- **Categories:** AI, Social media
- **Features:** Limited permissions
- **Stats:** 16 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $78.75 / 1,000 image generateds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

> # ⛔ DEPRECATED — DO NOT USE
>
> **This Actor is no longer maintained and should not be run.**
>
> It depends on a third-party inference endpoint whose availability we no longer guarantee.
> Runs may fail, hang, or return nothing.
>
> The documentation below is kept for reference only.

***

## 🎨 AI Image Generator — FLUX.1 Dev Photorealistic Images for Social Media

> 🔗 [View on Apify Store](https://apify.com/viralanalyzer/social-media-content-generator) | 🇺🇸 English | [🇧🇷 Português](#português)

Generate **stunning photorealistic AI images** with the **FLUX.1 Dev** model. Type a text prompt, pick an aspect ratio, and get high-quality images ready for Instagram, TikTok, YouTube, LinkedIn, blogs, ads, and creative projects. Images are rendered on a cloud **ZeroGPU A100** — **no local GPU, no setup, no API key required**.

Behind the scenes, your prompt is sent to the FLUX.1 Dev model (served via the ViralAnalyzer image-generator HuggingFace Space, Gradio API), and the finished image is saved to the run's Key-Value Store as a **WebP** file with full metadata in the dataset.

### ✨ Features

- 🖼️ **FLUX.1 Dev model** — State-of-the-art photorealistic text-to-image generation
- 📐 **3 aspect ratios** — Landscape 16:9 (1280×720), Square 1:1 (1024×1024), Portrait 9:16 (720×1280)
- 🔢 **Batch generation** — Up to 10 images per run from a single prompt (each with a unique result)
- 🎚️ **Quality controls** — Configurable inference `steps` (10–50) and `guidance` scale (1.0–10.0)
- ☁️ **Cloud GPU** — Runs on ZeroGPU A100; no GPU, drivers, or model downloads on your side
- 🔑 **No API key needed** — An optional HuggingFace token only speeds up the queue
- 💾 **WebP output** — Compact, web-ready images stored in the Key-Value Store with public URLs
- 🌱 **Reproducible** — The seed used for each image is returned in the metadata
- 🛟 **Smart reliability** — Auto wakes the GPU Space if it is sleeping, with retry/back-off

### 📥 Input

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `prompt` | string | ✅ | — | Describe the image (subject, style, lighting, mood). Be specific for best results. |
| `aspectRatio` | string | ❌ | `"16:9"` | One of `16:9` (Landscape 1280×720), `1:1` (Square 1024×1024), `9:16` (Portrait 720×1280). |
| `imageCount` | integer | ❌ | `1` | How many images to generate from the prompt (1–10). |
| `steps` | integer | ❌ | `28` | Inference steps (10–50). More steps = higher quality but slower. 28 is optimal for FLUX.1 Dev. |
| `guidance` | number | ❌ | `3.5` | Guidance scale (1.0–10.0). Higher = more literal to the prompt; lower = more creative. |
| `huggingfaceToken` | string (secret) | ❌ | — | Optional HuggingFace access token for a faster, prioritized queue. Get one free at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens). |

#### Input Example

```json
{
  "prompt": "A Brazilian beach at sunset with palm trees, photorealistic, cinematic lighting, 8K quality",
  "aspectRatio": "9:16",
  "imageCount": 3,
  "steps": 28,
  "guidance": 3.5
}
```

### 📤 Output

Each generated image is saved to the run's **Key-Value Store** as a WebP file (`image.webp`, or `image-01.webp`, `image-02.webp`… for batches). The **dataset** holds one metadata record per image:

| Field | Type | Description |
|---|---|---|
| `prompt` | string | The prompt used to generate the image |
| `aspectRatio` | string | Requested aspect ratio (`16:9`, `1:1`, `9:16`) |
| `width` | number | Image width in pixels |
| `height` | number | Image height in pixels |
| `steps` | number | Inference steps used |
| `guidance` | number | Guidance scale used |
| `seed` | number | Seed used for the generation (for reproducibility) |
| `imageNumber` | number | Position of the image in the batch (1-based) |
| `imageUrl` | string | Public Key-Value Store URL of the generated WebP image |
| `imageKey` | string | Key-Value Store key for the image file |
| `format` | string | Always `"webp"` |
| `sizeKB` | number | Image size in kilobytes |
| `model` | string | Always `"FLUX.1 Dev"` |
| `provider` | string | Always `"HuggingFace Space (ZeroGPU)"` |
| `generatedAt` | string | ISO 8601 timestamp |
| `ppeCharged` | boolean | Whether this run was charged via Pay Per Event |
| `ppeReason` | string | `owner`, `trial`, or `paid` |

> If an individual image fails, its record contains `imageUrl: null` and an `error` field describing the cause instead of the image metadata.

#### Output Example

```json
{
  "prompt": "A Brazilian beach at sunset with palm trees, photorealistic, cinematic lighting, 8K quality",
  "aspectRatio": "9:16",
  "width": 720,
  "height": 1280,
  "seed": 482913,
  "imageNumber": 1,
  "imageUrl": "https://api.apify.com/v2/key-value-stores/XXXX/records/image-01.webp",
  "imageKey": "image-01.webp",
  "format": "webp",
  "sizeKB": 312,
  "model": "FLUX.1 Dev",
  "provider": "HuggingFace Space (ZeroGPU)",
  "generatedAt": "2026-06-06T12:00:00.000Z",
  "ppeCharged": true,
  "ppeReason": "paid"
}
```

### 📋 Use Cases

- **Social media posts** — On-brand visuals sized for Instagram, Facebook, LinkedIn, TikTok, and YouTube
- **Stories & Reels** — Portrait 9:16 imagery for vertical formats
- **Ad creatives** — Generate multiple variations of a concept in a single run
- **Blog & article headers** — Landscape 16:9 hero images
- **Product & lifestyle mockups** — Photorealistic scenes without a photoshoot
- **Thumbnails** — Eye-catching cover art for videos and podcasts
- **Mood boards & ideation** — Batch-generate concepts to explore directions fast

### ❓ FAQ

**Q: Which model does this actor use?**
A: FLUX.1 Dev, a state-of-the-art text-to-image model, served on a cloud ZeroGPU A100 via the ViralAnalyzer image-generator HuggingFace Space.

**Q: Do I need a GPU or any API key?**
A: No. Generation runs entirely in the cloud. A HuggingFace token is optional and only improves queue priority/speed.

**Q: What image format and size do I get?**
A: WebP files at the resolution of your chosen aspect ratio: 16:9 → 1280×720, 1:1 → 1024×1024, 9:16 → 720×1280. The image URL is returned in the dataset and the file is stored in the run's Key-Value Store.

**Q: How many images can I generate per run?**
A: Up to 10 per run (`imageCount`). All use the same prompt but produce unique results.

**Q: What do `steps` and `guidance` do?**
A: `steps` controls how many denoising iterations run (more = higher quality, slower; 28 is recommended). `guidance` controls how strictly the image follows your prompt (3.5 is recommended; higher is more literal, lower is more creative).

**Q: The run finished but I got no image — why?**
A: The GPU Space may have been waking from sleep, the queue may have timed out, or a token may have been missing. On these recoverable cases the run ends successfully with a diagnostic guide (and is **not** charged). Retry in a minute, add a HuggingFace token, or reduce `imageCount` to 1.

**Q: Is there a free trial?**
A: Yes — the first run per user is free so you can test before paying.

### 💰 Pricing

This actor uses **Pay Per Event (PPE)**. You are charged once per generated image (event `content-generated`). The first run per user is free, and runs that produce no usable image are not charged. The Apify platform fee is included.

👉 For the current price, see the **Pricing** tab on the actor page: **https://apify.com/viralanalyzer/social-media-content-generator**

### 🔗 Related Actors

- [TradingView Screener](https://apify.com/viralanalyzer/tradingview-screener) — Technical analysis & market scanner
- [Yahoo Finance Intelligence](https://apify.com/viralanalyzer/yahoo-finance-intelligence) — Stock quotes, fundamentals & analyst ratings
- [Influencer Discovery Agent](https://apify.com/viralanalyzer/influencer-discovery-agent) — Find creators across platforms
- [Shopify Store Intelligence](https://apify.com/viralanalyzer/shopify-store-intelligence) — E-commerce competitive analysis

### 📝 Changelog

#### v2.0 (Current)

- ✅ FLUX.1 Dev photorealistic text-to-image generation
- ✅ Cloud ZeroGPU A100 rendering (no local GPU required)
- ✅ Three aspect ratios: 16:9, 1:1, 9:16
- ✅ Batch generation up to 10 images per run
- ✅ Configurable inference `steps` and `guidance` scale
- ✅ WebP output saved to Key-Value Store with public URLs and per-image metadata
- ✅ Seed returned for reproducibility
- ✅ Automatic GPU Space wake-up with retry/back-off
- ✅ Pre-charge before GPU usage + 1 free trial run per user
- ✅ Diagnostic Setup Guide on recoverable failures (no charge)
- ✅ Pay Per Event billing with owner-account skip

***

<a name="português"></a>

## 🎨 Gerador de Imagens IA — Imagens Fotorrealistas FLUX.1 Dev para Redes Sociais

> 🔗 [Ver na Apify Store](https://apify.com/viralanalyzer/social-media-content-generator) | [🇺🇸 English](#-ai-image-generator--flux1-dev-photorealistic-images-for-social-media) | 🇧🇷 Português

Gere **imagens fotorrealistas impressionantes com IA** usando o modelo **FLUX.1 Dev**. Digite um prompt de texto, escolha o formato (proporção) e receba imagens de alta qualidade prontas para Instagram, TikTok, YouTube, LinkedIn, blogs, anúncios e projetos criativos. As imagens são renderizadas em uma **GPU A100 na nuvem (ZeroGPU)** — **sem GPU local, sem configuração e sem chave de API**.

Nos bastidores, seu prompt é enviado ao modelo FLUX.1 Dev (servido pelo HuggingFace Space image-generator da ViralAnalyzer, via API Gradio), e a imagem final é salva no Key-Value Store da execução como arquivo **WebP**, com os metadados completos no dataset.

### ✨ Funcionalidades

- 🖼️ **Modelo FLUX.1 Dev** — Geração de texto-para-imagem fotorrealista de ponta
- 📐 **3 proporções** — Paisagem 16:9 (1280×720), Quadrada 1:1 (1024×1024), Retrato 9:16 (720×1280)
- 🔢 **Geração em lote** — Até 10 imagens por execução a partir de um único prompt (cada uma única)
- 🎚️ **Controles de qualidade** — `steps` de inferência configuráveis (10–50) e escala de `guidance` (1.0–10.0)
- ☁️ **GPU na nuvem** — Roda em ZeroGPU A100; sem GPU, drivers ou download de modelos do seu lado
- 🔑 **Sem chave de API** — O token HuggingFace é opcional e só agiliza a fila
- 💾 **Saída WebP** — Imagens compactas e prontas para a web no Key-Value Store, com URLs públicas
- 🌱 **Reproduzível** — A seed usada em cada imagem é retornada nos metadados
- 🛟 **Confiabilidade inteligente** — Acorda automaticamente o Space da GPU se estiver dormindo, com retry/back-off

### 📥 Entrada

| Parâmetro | Tipo | Obrigatório | Padrão | Descrição |
|---|---|---|---|---|
| `prompt` | string | ✅ | — | Descreva a imagem (assunto, estilo, iluminação, clima). Seja específico para melhores resultados. |
| `aspectRatio` | string | ❌ | `"16:9"` | Um de `16:9` (Paisagem 1280×720), `1:1` (Quadrada 1024×1024), `9:16` (Retrato 720×1280). |
| `imageCount` | integer | ❌ | `1` | Quantas imagens gerar a partir do prompt (1–10). |
| `steps` | integer | ❌ | `28` | Passos de inferência (10–50). Mais passos = maior qualidade, porém mais lento. 28 é ideal para o FLUX.1 Dev. |
| `guidance` | number | ❌ | `3.5` | Escala de orientação (1.0–10.0). Maior = mais literal ao prompt; menor = mais criativo. |
| `huggingfaceToken` | string (secreto) | ❌ | — | Token de acesso HuggingFace opcional para fila mais rápida e prioritária. Pegue um grátis em [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens). |

#### Exemplo de Entrada

```json
{
  "prompt": "Uma praia brasileira ao pôr do sol com coqueiros, fotorrealista, iluminação cinematográfica, qualidade 8K",
  "aspectRatio": "9:16",
  "imageCount": 3,
  "steps": 28,
  "guidance": 3.5
}
```

### 📤 Saída

Cada imagem gerada é salva no **Key-Value Store** da execução como arquivo WebP (`image.webp`, ou `image-01.webp`, `image-02.webp`… para lotes). O **dataset** guarda um registro de metadados por imagem:

| Campo | Tipo | Descrição |
|---|---|---|
| `prompt` | string | O prompt usado para gerar a imagem |
| `aspectRatio` | string | Proporção solicitada (`16:9`, `1:1`, `9:16`) |
| `width` | número | Largura da imagem em pixels |
| `height` | número | Altura da imagem em pixels |
| `steps` | número | Passos de inferência usados |
| `guidance` | número | Escala de orientação usada |
| `seed` | número | Seed usada na geração (para reprodutibilidade) |
| `imageNumber` | número | Posição da imagem no lote (começa em 1) |
| `imageUrl` | string | URL pública no Key-Value Store da imagem WebP gerada |
| `imageKey` | string | Chave do arquivo de imagem no Key-Value Store |
| `format` | string | Sempre `"webp"` |
| `sizeKB` | número | Tamanho da imagem em kilobytes |
| `model` | string | Sempre `"FLUX.1 Dev"` |
| `provider` | string | Sempre `"HuggingFace Space (ZeroGPU)"` |
| `generatedAt` | string | Timestamp ISO 8601 |
| `ppeCharged` | boolean | Se esta execução foi cobrada via Pay Per Event |
| `ppeReason` | string | `owner`, `trial` ou `paid` |

> Se uma imagem individual falhar, seu registro contém `imageUrl: null` e um campo `error` descrevendo a causa, no lugar dos metadados da imagem.

#### Exemplo de Saída

```json
{
  "prompt": "Uma praia brasileira ao pôr do sol com coqueiros, fotorrealista, iluminação cinematográfica, qualidade 8K",
  "aspectRatio": "9:16",
  "width": 720,
  "height": 1280,
  "seed": 482913,
  "imageNumber": 1,
  "imageUrl": "https://api.apify.com/v2/key-value-stores/XXXX/records/image-01.webp",
  "imageKey": "image-01.webp",
  "format": "webp",
  "sizeKB": 312,
  "model": "FLUX.1 Dev",
  "provider": "HuggingFace Space (ZeroGPU)",
  "generatedAt": "2026-06-06T12:00:00.000Z",
  "ppeCharged": true,
  "ppeReason": "paid"
}
```

### 📋 Casos de Uso

- **Posts para redes sociais** — Visuais alinhados à marca, no tamanho de Instagram, Facebook, LinkedIn, TikTok e YouTube
- **Stories & Reels** — Imagens retrato 9:16 para formatos verticais
- **Criativos de anúncio** — Gere várias variações de um conceito em uma única execução
- **Capas de blog & artigos** — Imagens de destaque em paisagem 16:9
- **Mockups de produto & lifestyle** — Cenas fotorrealistas sem sessão de fotos
- **Thumbnails** — Capas chamativas para vídeos e podcasts
- **Mood boards & ideação** — Gere conceitos em lote para explorar direções rapidamente

### ❓ Perguntas Frequentes

**P: Qual modelo este actor usa?**
R: FLUX.1 Dev, um modelo de texto-para-imagem de ponta, servido em uma GPU A100 na nuvem (ZeroGPU) pelo HuggingFace Space image-generator da ViralAnalyzer.

**P: Preciso de GPU ou chave de API?**
R: Não. A geração roda inteiramente na nuvem. Um token HuggingFace é opcional e só melhora a prioridade/velocidade da fila.

**P: Qual formato e tamanho de imagem eu recebo?**
R: Arquivos WebP na resolução da proporção escolhida: 16:9 → 1280×720, 1:1 → 1024×1024, 9:16 → 720×1280. A URL da imagem é retornada no dataset e o arquivo fica no Key-Value Store da execução.

**P: Quantas imagens posso gerar por execução?**
R: Até 10 por execução (`imageCount`). Todas usam o mesmo prompt, mas produzem resultados únicos.

**P: O que `steps` e `guidance` fazem?**
R: `steps` controla quantas iterações de denoising rodam (mais = maior qualidade, mais lento; 28 é o recomendado). `guidance` controla o quão estritamente a imagem segue o prompt (3.5 é o recomendado; maior é mais literal, menor é mais criativo).

**P: A execução terminou, mas não recebi imagem — por quê?**
R: O Space da GPU pode ter acordado do modo de espera, a fila pode ter expirado, ou o token pode ter faltado. Nesses casos recuperáveis, a execução termina com sucesso exibindo um guia de diagnóstico (e **não** é cobrada). Tente novamente em um minuto, adicione um token HuggingFace ou reduza `imageCount` para 1.

**P: Existe teste grátis?**
R: Sim — a primeira execução por usuário é gratuita para você testar antes de pagar.

### 💰 Preços

Este actor usa **Pay Per Event (PPE)**. Você é cobrado uma vez por imagem gerada (evento `content-generated`). A primeira execução por usuário é gratuita, e execuções que não produzem imagem utilizável não são cobradas. A taxa da plataforma Apify já está incluída.

👉 Para o preço atual, veja a aba **Pricing** na página do actor: **https://apify.com/viralanalyzer/social-media-content-generator**

### 🔗 Actors Relacionados

- [TradingView Screener](https://apify.com/viralanalyzer/tradingview-screener) — Análise técnica & scanner de mercado
- [Yahoo Finance Intelligence](https://apify.com/viralanalyzer/yahoo-finance-intelligence) — Cotações, fundamentos & ratings de analistas
- [Influencer Discovery Agent](https://apify.com/viralanalyzer/influencer-discovery-agent) — Encontre criadores em várias plataformas
- [Shopify Store Intelligence](https://apify.com/viralanalyzer/shopify-store-intelligence) — Análise competitiva de e-commerce

### 📝 Changelog

#### v2.0 (Atual)

- ✅ Geração de texto-para-imagem fotorrealista com FLUX.1 Dev
- ✅ Renderização em GPU A100 na nuvem (ZeroGPU) — sem GPU local
- ✅ Três proporções: 16:9, 1:1, 9:16
- ✅ Geração em lote de até 10 imagens por execução
- ✅ `steps` de inferência e escala de `guidance` configuráveis
- ✅ Saída WebP salva no Key-Value Store com URLs públicas e metadados por imagem
- ✅ Seed retornada para reprodutibilidade
- ✅ Acordar automático do Space da GPU com retry/back-off
- ✅ Pré-cobrança antes de usar a GPU + 1 execução de teste grátis por usuário
- ✅ Guia de Diagnóstico em falhas recuperáveis (sem cobrança)
- ✅ Cobrança Pay Per Event com isenção da conta do dono (owner-skip)

# Actor input Schema

## `prompt` (type: `string`):

Describe the image you want to generate. Be specific: subject, style, lighting, mood. E.g., 'A Brazilian beach at sunset with palm trees, photorealistic, cinematic lighting, 8K quality'.

## `aspectRatio` (type: `string`):

Image dimensions. 16:9 for YouTube/LinkedIn, 1:1 for Instagram/Facebook, 9:16 for Stories/Reels/TikTok.

## `imageCount` (type: `integer`):

How many images to generate from this prompt (1-10). Each image uses the same prompt but produces unique results.

## `steps` (type: `integer`):

More steps = higher quality but slower. 28 is optimal for FLUX.1 Dev.

## `guidance` (type: `number`):

How closely to follow the prompt. 3.5 is recommended for FLUX.1 Dev. Higher = more literal, lower = more creative.

## `huggingfaceToken` (type: `string`):

Your HuggingFace access token. Recommended for faster queue times. Get one free at https://huggingface.co/settings/tokens

## Actor input object example

```json
{
  "prompt": "A futuristic city skyline at sunset with neon lights reflecting on water, photorealistic, cinematic lighting, ultra detailed",
  "aspectRatio": "16:9",
  "imageCount": 1,
  "steps": 28,
  "guidance": 3.5
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing metadata for each generated image (URL, dimensions, prompt, model).

# 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 = {
    "prompt": "A futuristic city skyline at sunset with neon lights reflecting on water, photorealistic, cinematic lighting, ultra detailed"
};

// Run the Actor and wait for it to finish
const run = await client.actor("viralanalyzer/social-media-content-generator").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 = { "prompt": "A futuristic city skyline at sunset with neon lights reflecting on water, photorealistic, cinematic lighting, ultra detailed" }

# Run the Actor and wait for it to finish
run = client.actor("viralanalyzer/social-media-content-generator").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 '{
  "prompt": "A futuristic city skyline at sunset with neon lights reflecting on water, photorealistic, cinematic lighting, ultra detailed"
}' |
apify call viralanalyzer/social-media-content-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,viralanalyzer/social-media-content-generator"
        }
    }
}
```

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/bLoAYkOd0oROvPnnG/builds/TqMNgsoDevYaFnTya/openapi.json