# SEO Article Generator with Website Context (`uduzgun/seo-article-draft-generator`) Actor

Generate review-ready SEO article drafts from a topic, website, or YouTube video. Uses website context, search intent, brand notes, metadata, FAQs, sources, internal-link suggestions, and optional featured images for blogs, SaaS, e-commerce, and service pages.

- **URL**: https://apify.com/uduzgun/seo-article-draft-generator.md
- **Developed by:** [Uygar Duzgun](https://apify.com/uduzgun) (community)
- **Categories:** Automation, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 96.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2,000.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## SEO Article Generator with Website Context

Generate SEO-ready article drafts from a topic or YouTube URL using customer website context, search intent, metadata, FAQs, and internal-link suggestions.

This is not a generic AI article writer. It uses a multi-step SEO content workflow built from practical e-commerce SEO work, where organic search is one of the most heavily invested growth channels. The workflow uses website context, target page context, source material, article structure, metadata, FAQ ideas, and internal-link opportunities before returning a review-ready draft.

This Actor calls the Uygar Content API at `/api/v1/generate`, waits for the server-sent event result, and writes one structured dataset item with the article draft and SEO metadata. Add the customer's website, target page, reference articles, brand notes, audience details, or product context to make the draft fit the business behind the article.

### Who it is for

Use this Actor when you need a strong first draft for a blog, service page, category-support article, or content brief and want the SEO structure handled before an editor reviews the piece. It is built for agencies, consultants, SaaS teams, e-commerce operators, local service businesses, and teams that publish SEO content regularly.

This is not an automatic publishing pipeline and it does not guarantee rankings. It produces a structured draft with SEO fields, source context, FAQ ideas, and internal-link suggestions so a human editor can publish faster with better inputs.

### What it does

- Turns a topic, keyword, title idea, or YouTube URL into a markdown SEO article draft.
- Uses supplied company website, target page, reference articles, brand context, audience notes, and product details when you provide them.
- Adds focus keyword, SEO keywords, meta description, FAQ, sources, and internal-link suggestions when returned by the backend.
- Can generate an optional featured image.
- Keeps raw model output out of the public dataset, while returning a usage summary with model breakdown, tokens, calls, and estimated cost.

### Use cases

- Draft blog posts for AI automation, SaaS, consulting, local service, and B2B websites.
- Turn YouTube tutorials or product videos into article drafts.
- Create Swedish or English article drafts with brand context.
- Produce a first draft with SEO metadata that an editor can review before publishing.

### What you get

Each successful run returns one article package:

- markdown article draft
- title, excerpt, focus keyword, SEO keywords, and meta description
- FAQ suggestions and source references when available
- internal-link suggestions for site owners
- optional featured image URL
- SEO score returned by the backend
- usage summary with model breakdown, input/output tokens, LLM calls, and estimated cost

### Input

- `sourceType`: `topic_research` for a topic idea or `youtube_video` for a YouTube URL.
- `sourceInput`: article topic, keyword, title idea, or YouTube URL.
- `companyWebsite`: the customer's public website for brand and offer context.
- `articleDestinationUrl`: where the article will be published, or the page/category it should support.
- `referenceUrls`: optional public customer pages or existing articles, one URL per line.
- `language`: `en` or `sv`.
- `tone`: `professional`, `conversational`, or `technical`.
- `targetWordCount`: target article length from 600 to 1600 words.
- `generateImage`: generate a featured image when enabled.
- `findYoutube`: include related YouTube tutorials when available.
- `niche` and `clientContext`: optional brand, audience, product, public-page summary, and editorial instructions.

Advanced/private inputs:

- `apiKey`: optional customer-scoped Uygar Content API key override. Leave it blank on public Store runs.

### Example inputs

Topic to article:

```json
{
  "sourceType": "topic_research",
  "sourceInput": "AI automation for small business support teams",
  "companyWebsite": "https://example.com",
  "articleDestinationUrl": "https://example.com/blog/ai-automation-support",
  "referenceUrls": "https://example.com/services\nhttps://example.com/blog/customer-support-guide",
  "niche": "AI automation consulting",
  "tone": "professional",
  "targetWordCount": 600,
  "language": "en",
  "generateImage": false,
  "findYoutube": false,
  "clientContext": "Write for founders and operations managers. The company sells practical AI automation workshops and wants direct, non-hype content."
}
```

YouTube video to article:

```json
{
  "sourceType": "youtube_video",
  "sourceInput": "https://www.youtube.com/watch?v=VIDEO_ID",
  "tone": "technical",
  "targetWordCount": 1000,
  "language": "en",
  "generateImage": true
}
```

### Output

The default dataset contains one item with:

- request ID and status
- title, excerpt, focus keyword, SEO keywords, meta description
- markdown article content
- SEO score when returned by the backend
- image URL when generated
- internal links, FAQ, sources, claim checks, YouTube tutorials, URL QA warnings
- usage summary with model breakdown, tokens, LLM calls, and estimated cost

### Limits and review

This Actor creates drafts, not legal, medical, financial, or compliance advice. Review facts, claims, and citations before publishing. Image generation and YouTube enrichment can add runtime and cost. YouTube conversion requires a public transcript or captions; videos without a usable transcript fail with a clear transcript error.

# Actor input Schema

## `apiKey` (type: `string`):

Optional advanced override. Leave blank on public Store runs; the Actor owner should configure UYGAR_CONTENT_API_KEY as a secret environment variable.

## `sourceType` (type: `string`):

Use topic_research for a topic idea or youtube_video for a YouTube URL.

## `sourceInput` (type: `string`):

The article topic, keyword, title idea, or YouTube URL.

## `companyWebsite` (type: `string`):

The public company website to use for brand, offer, audience, and internal-link context.

## `articleDestinationUrl` (type: `string`):

Where the article will be published, or the page/category the article should support.

## `referenceUrls` (type: `string`):

Optional public customer pages or existing articles to use as context. Add one URL per line.

## `niche` (type: `string`):

Optional niche or industry context.

## `tone` (type: `string`):

Writing tone for the article draft.

## `targetWordCount` (type: `integer`):

Target article length. The backend may cap or adjust this depending on runtime constraints.

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

Article output language.

## `generateImage` (type: `boolean`):

Generate a featured image for the article.

## `findYoutube` (type: `boolean`):

Include related YouTube tutorials when available.

## `clientContext` (type: `string`):

Brand voice, audience, products, public-page summaries, exclusions, or editorial instructions.

## Actor input object example

```json
{
  "sourceType": "topic_research",
  "sourceInput": "Best AI tools for small business automation",
  "tone": "professional",
  "targetWordCount": 600,
  "language": "en",
  "generateImage": false,
  "findYoutube": false
}
```

# Actor output Schema

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

Default dataset items containing the generated markdown article, SEO metadata, and usage summary.

# 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 = {
    "sourceInput": "Best AI tools for small business automation"
};

// Run the Actor and wait for it to finish
const run = await client.actor("uduzgun/seo-article-draft-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 = { "sourceInput": "Best AI tools for small business automation" }

# Run the Actor and wait for it to finish
run = client.actor("uduzgun/seo-article-draft-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 '{
  "sourceInput": "Best AI tools for small business automation"
}' |
apify call uduzgun/seo-article-draft-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,uduzgun/seo-article-draft-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/fYKxa1GQNOAv9CA7d/builds/7tDmm6gr35YfsYkhI/openapi.json