# Html Lang Validator (`zerobreak/html-lang-validator`) Actor
HTML lang validator that checks any webpage for missing or invalid lang attributes, so developers and SEO teams can fix language tag errors across large sites without clicking through pages one by one.
- **URL**: https://apify.com/zerobreak/html-lang-validator.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.99 / 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/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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
## HTML Lang Validator: Check and Fix Missing Lang Attributes on Any Website
HTML lang validator checks every URL you give it for a missing or invalid `lang` attribute on the `` tag. The `lang` attribute tells browsers and screen readers what language a page is written in. Leave it out and you create an ambiguity that costs you in accessibility audits and search rankings. Most site audits catch broken links and slow pages but skip the lang check entirely.
Point the actor at one URL or feed it a list of hundreds. It fetches each page, reads the `lang` attribute, and validates the value against BCP 47 rules. Results land in a dataset with the exact lang value found, HTTP status, page title, and a plain list of any issues detected.
### Use cases
- **SEO auditing**: find pages with missing lang attributes before they hurt international SEO performance
- **Accessibility compliance**: flag lang attribute errors that break screen reader language detection
- **Site migrations**: validate lang attributes across every page after a CMS or template change
- **Multilingual site QA**: confirm each language variant has the correct lang value set
- **Bulk content audits**: check hundreds of URLs without opening each page by hand
### Input
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `url` | string | - | Single URL to validate |
| `urls` | array | - | List of URLs to validate, one per line |
| `maxUrls` | integer | 100 | Maximum URLs to process per run (max: 1000) |
| `requestTimeoutSecs` | integer | 30 | Per-request timeout in seconds |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location for requests. Supports Datacenter, Residential, Special, and custom proxies. Optional. |
#### Example input
```json
{
"urls": [
"https://apify.com/",
"https://apify.com/store",
"https://apify.com/about"
],
"maxUrls": 100,
"requestTimeoutSecs": 30,
"proxyConfiguration": { "useApifyProxy": true }
}
```
### What data does this actor collect?
Each result in the dataset contains:
```json
{
"url": "https://apify.com/",
"httpStatus": 200,
"pageTitle": "Apify: Full-stack web scraping and data extraction platform",
"langValue": "en",
"xmlLangValue": null,
"isLangPresent": true,
"isLangValid": true,
"issues": [],
"hasIssues": false,
"error": null,
"checkedAt": "2025-03-04T10:23:41.123456+00:00"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Final URL after any redirects |
| `httpStatus` | integer | HTTP response status code |
| `pageTitle` | string | Page title from the `` tag |
| `langValue` | string | Value of the `lang` attribute. Null if missing. |
| `xmlLangValue` | string | Value of `xml:lang` (used in XHTML documents). Null if not present. |
| `isLangPresent` | boolean | True if a `lang` attribute exists on the `<html>` tag |
| `isLangValid` | boolean | True if the `lang` value passes BCP 47 validation |
| `issues` | array | List of validation issues found for this URL |
| `hasIssues` | boolean | True if any issues were detected |
| `error` | string | Error message if the page could not be fetched. Null otherwise. |
| `checkedAt` | string | ISO 8601 timestamp of when the check ran |
### How it works
1. Collects URLs from `url` and `urls` inputs, deduplicates them, and caps at `maxUrls`
2. Fetches each page with an async HTTP client using a realistic browser user-agent
3. Parses the HTML with BeautifulSoup and reads the `lang` attribute from the `<html>` tag
4. Validates the value against BCP 47 language tag rules
5. Flags issues: missing attribute, empty value, or invalid format
6. Pushes results to the dataset in real time as each URL finishes
### Integrations
Connect HTML Lang Validator with other apps using [Apify integrations](https://apify.com/integrations). You can pipe results into Google Sheets, trigger Slack alerts via Make or Zapier, or connect to Airbyte for data warehouse ingestion. Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger downstream actions as soon as a run completes.
### FAQ
**What counts as a valid lang attribute?**
The actor validates against BCP 47 language tags. Values like `en`, `en-US`, `fr`, `zh-Hant`, and `pt-BR` all pass. Values like `english`, `EN_US`, or an empty string fail.
**What happens if a page returns a 404 or 5xx error?**
The actor records the HTTP status and writes an error message to the result. It keeps processing the rest of the list rather than stopping.
**Can it handle XHTML pages that use xml:lang instead of lang?**
Yes. The actor reads both `lang` and `xml:lang`. If only `xml:lang` is found, it flags the missing `lang` attribute and notes the xml:lang value in the result.
**How many URLs can it process in one run?**
Up to 1,000 per run. Use `maxUrls` to keep runs smaller during testing.
**Does it follow redirects?**
Yes. The actor follows HTTP redirects automatically and reports the final URL after all hops.
**Can I run this on a schedule?**
Yes. Set up a scheduled run in Apify Console to monitor your site's lang attribute compliance over time and catch regressions after deployments.
***
Run the HTML lang validator on your site and get a full report on missing or invalid lang attributes. Export results as JSON or CSV, or push them directly to Google Sheets for review.
# Actor input Schema
## `url` (type: `string`):
A single URL to validate. The actor checks the HTML lang attribute on this page.
## `urls` (type: `array`):
A list of URLs to validate. One URL per line. Use this to check multiple pages in a single run.
## `maxUrls` (type: `integer`):
Maximum number of URLs to process per run. Useful for capping costs on large lists. Maximum allowed: 1000.
## `requestTimeoutSecs` (type: `integer`):
How long to wait for each page to respond before giving up. Increase for slow sites.
## `proxyConfiguration` (type: `object`):
Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.
## Actor input object example
```json
{
"url": "https://apify.com/",
"urls": [
"https://apify.com/",
"https://apify.com/store"
],
"maxUrls": 100,
"requestTimeoutSecs": 30,
"proxyConfiguration": {
"useApifyProxy": 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 = {
"url": "https://apify.com/",
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/html-lang-validator").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 = {
"url": "https://apify.com/",
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("zerobreak/html-lang-validator").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 '{
"url": "https://apify.com/",
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call zerobreak/html-lang-validator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,zerobreak/html-lang-validator"
}
}
}
```
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/gOZauFbrj4Pf4M6HC/builds/84p9GFgdOhefRbBKo/openapi.json