# Website Word Count (`coder_luffy/website-word-count`) Actor

Analyze word count and content depth of any web page. Get word count, sentence count, paragraph count, heading count, and SEO content assessment for one or multiple URLs in a single run.

- **URL**: https://apify.com/coder\_luffy/website-word-count.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** SEO tools, Integrations
- **Stats:** 6 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

## Website Word Count

Analyze the word count and textual content of any web page. Get instant SEO content assessments with detailed statistics — word count, sentence count, paragraph count, heading count, and more. Supports analyzing one or multiple URLs in a single run.

### What is Website Word Count?

Numerous studies have shown that there is a relationship between the amount of content on a page (typically measured in word count) and its ranking potential — generally, longer content will rank higher. Obviously content also needs to be topically relevant, keyword-rich, and highly readable for the visitor.

Website Word Count extracts all visible (selectable) text from any web page — ignoring scripts, styles, navigation, and hidden elements — and gives you a complete content breakdown with an actionable SEO assessment.

### Use cases

- **SEO content audits** — quickly check whether your pages have enough content to compete in search results
- **Competitor analysis** — compare word counts across competitor pages to benchmark your content strategy
- **Content migration** — verify word counts before and after a site migration to ensure no content was lost
- **Bulk page analysis** — analyze hundreds of URLs at once by passing them as a list
- **Editorial workflow** — validate that published pages meet your minimum content guidelines

### Input

| Field | Type | Description |
|-------|------|-------------|
| `urls` | array of strings | List of website URLs to analyze |
| `url` | string | A single URL to analyze (alternative to `urls`) |
| `minWordCount` | integer | Minimum recommended word count for SEO (default: `500`) |
| `includeMetaData` | boolean | Whether to include meta title and description (default: `true`) |

#### Input example

```json
{
    "urls": [
        "https://example.com",
        "https://example.com/about",
        "https://example.com/blog/post-1"
    ],
    "minWordCount": 500,
    "includeMetaData": true
}
````

### Output

The Actor stores results in a dataset. Each URL produces one result object:

```json
{
    "url": "https://example.com",
    "wordCount": 1391,
    "status": "good",
    "assessment": "Your page has a good level of textual content, which will assist in its ranking potential.",
    "recommendation": "Your page has 1391 words, which meets the recommended minimum of 500 words. Well-written, keyword-rich content at this length gives your page solid ranking potential.",
    "characterCount": 8350,
    "sentenceCount": 95,
    "paragraphCount": 42,
    "headingCount": 12,
    "avgWordsPerSentence": 14.6,
    "metaTitle": "Example - Homepage",
    "metaDescription": "Welcome to Example, the leading platform for...",
    "analyzedAt": "2026-02-25T10:30:00.000000+00:00"
}
```

#### Status values

| Status | Word Count | Meaning |
|--------|-----------|---------|
| `good` | >= minimum | Page has a good level of textual content for ranking potential |
| `warning` | 50–99% of minimum | Page could benefit from more content |
| `poor` | < 50% of minimum | Page has very little content and may struggle to rank |
| `error` | — | The page could not be fetched or analyzed |

### How it works

1. Accepts one or multiple URLs as input
2. Fetches each page's HTML content with a realistic browser User-Agent
3. Parses the HTML and strips non-visible elements (scripts, styles, hidden content, comments, nav, footer)
4. Extracts all visible, selectable text — the same text a user could highlight on the page
5. Counts words, characters, sentences, paragraphs, and headings
6. Generates an SEO assessment based on the configurable word count threshold
7. Optionally extracts the page's meta title and meta description
8. Stores all results in the dataset for export in JSON, CSV, Excel, or other formats

### Integrations

Website Word Count can be connected with almost any cloud service or web app via [integrations on the Apify platform](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. Or you can use [webhooks](https://docs.apify.com/integrations/webhooks) to take actions whenever an Actor run is finished.

# Actor input Schema

## `urls` (type: `array`):

List of website URLs to analyze for word count. Each URL will be visited and its visible text content will be counted.

## `url` (type: `string`):

A single URL to analyze. Use this or 'urls' field. If both are provided, this URL is added to the list.

## `minWordCount` (type: `integer`):

The minimum word count threshold for SEO recommendations. Pages below this count will receive a warning.

## `includeMetaData` (type: `boolean`):

Whether to extract and include meta title and description in the results.

## Actor input object example

```json
{
  "urls": [
    "https://www.apify.com/"
  ],
  "minWordCount": 500,
  "includeMetaData": true
}
```

# 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 = {
    "urls": [
        "https://www.apify.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/website-word-count").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 = { "urls": ["https://www.apify.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("coder_luffy/website-word-count").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 '{
  "urls": [
    "https://www.apify.com/"
  ]
}' |
apify call coder_luffy/website-word-count --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Word Count",
        "description": "Analyze word count and content depth of any web page. Get word count, sentence count, paragraph count, heading count, and SEO content assessment for one or multiple URLs in a single run.",
        "version": "0.0",
        "x-build-id": "RSLBgablGZaE78xrU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coder_luffy~website-word-count/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coder_luffy-website-word-count",
                "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/coder_luffy~website-word-count/runs": {
            "post": {
                "operationId": "runs-sync-coder_luffy-website-word-count",
                "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/coder_luffy~website-word-count/run-sync": {
            "post": {
                "operationId": "run-sync-coder_luffy-website-word-count",
                "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": {
                    "urls": {
                        "title": "URLs to analyze",
                        "type": "array",
                        "description": "List of website URLs to analyze for word count. Each URL will be visited and its visible text content will be counted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "url": {
                        "title": "Single URL (alternative)",
                        "type": "string",
                        "description": "A single URL to analyze. Use this or 'urls' field. If both are provided, this URL is added to the list."
                    },
                    "minWordCount": {
                        "title": "Minimum recommended word count",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The minimum word count threshold for SEO recommendations. Pages below this count will receive a warning.",
                        "default": 500
                    },
                    "includeMetaData": {
                        "title": "Include meta data",
                        "type": "boolean",
                        "description": "Whether to extract and include meta title and description in the results.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
