Actor SEO Auditor

Audit your Apify actor Store listings for SEO quality and get a score from 0 to 100 with a letter grade. Actor SEO Auditor checks 10 critical ranking factors — title length, description, README quality, categories, pricing, input schema, dataset schema, icon, and example output — then generates prioritized recommendations to improve your Store visibility. Built for Apify developers who want their actors discovered and adopted.

Features

• Scores each actor on a 0-100 scale across 10 weighted SEO checks
• Assigns a letter grade (A through F) for quick assessment
• Audits title length against the optimal 40-60 character window
• Validates description length against the 150-300 character sweet spot
• Checks README presence, length (target 2000+ characters), and example output
• Verifies category assignment, PPE pricing configuration, and custom icon
• Inspects input schema field completeness and dataset schema definition
• Generates plain-English, actionable recommendations sorted by impact
• Audits all your actors in a single run or targets specific ones by name
• Results sorted worst-first so you fix the biggest problems first

Use Cases

• Apify developers preparing to publish: Run an audit before going public to catch missing metadata, short descriptions, and absent READMEs that would hurt your Store ranking.
• Actor portfolio managers: Audit your entire catalog at once to identify which actors need documentation improvements and prioritize effort.
• Apify Store optimization: Systematically raise your quality scores across all 10 dimensions that affect Store search ranking and user trust.
• Pre-launch checklist: Use the recommendations as a to-do list before publishing each new actor to ensure nothing is missing.

How to Use

1. Click Try for free on this actor's Store page.
2. Enter your Apify API Token (find it at console.apify.com/settings/integrations).
3. Optionally enter specific Actor Names to audit. Leave empty to audit all your actors.
4. Click Start and wait for the run to finish.
5. View audit results in the Dataset tab. Download as JSON, CSV, or Excel.

Input Parameters

Output Example

The actor returns one audit result per actor, sorted by score ascending (worst first):

{
  "actorName": "website-contact-scraper",
  "actorId": "abc123def456",
  "overallScore": 68,
  "grade": "C",
  "checks": {
    "titleLength": {
      "score": 10,
      "maxScore": 10,
      "status": "pass",
      "detail": "52 chars (optimal 40-60)"
    },
    "descriptionLength": {
      "score": 5,
      "maxScore": 10,
      "status": "warn",
      "detail": "89 chars (short, optimal 150-300)"
    },
    "hasReadme": {
      "score": 15,
      "maxScore": 15,
      "status": "pass",
      "detail": "README present, 1847 chars"
    },
    "readmeLength": {
      "score": 5,
      "maxScore": 10,
      "status": "warn",
      "detail": "1847 chars (short: aim for >2000)"
    },
    "hasCategories": {
      "score": 10,
      "maxScore": 10,
      "status": "pass",
      "detail": "2 categories assigned"
    },
    "hasPricing": {
      "score": 10,
      "maxScore": 10,
      "status": "pass",
      "detail": "PPE pricing set"
    },
    "hasInputSchema": {
      "score": 5,
      "maxScore": 10,
      "status": "warn",
      "detail": "4 fields, 2 with descriptions"
    },
    "hasDatasetSchema": {
      "score": 0,
      "maxScore": 10,
      "status": "fail",
      "detail": "No dataset schema defined"
    },
    "hasIcon": {
      "score": 5,
      "maxScore": 5,
      "status": "pass",
      "detail": "Custom icon set"
    },
    "hasExampleOutput": {
      "score": 3,
      "maxScore": 10,
      "status": "warn",
      "detail": "Output section found but no JSON example"
    }
  },
  "recommendations": [
    "Expand description to 150-300 characters for better search visibility",
    "Expand README to 2000+ characters — include use cases, API examples (Python, JavaScript, cURL), and sample output",
    "Add descriptions to all input schema fields",
    "Define a dataset schema in .actor/dataset_schema.json so users can preview output structure",
    "Add a JSON code block with example output to your README — helps users understand what they get"
  ],
  "analyzedAt": "2026-03-18T14:30:00.000Z"
}

Output Fields

Each CheckResult object contains:

How Much Does It Cost?

This actor uses Pay-Per-Event pricing at $0.10 per audit. You are charged once per run, regardless of how many actors are audited.

The Apify Free plan includes $5 of monthly credits — enough for approximately 50 audits.

API Examples

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("UFM00vXOcr9bEMoHj").call(run_input={
    "apiToken": "YOUR_APIFY_TOKEN",
    "actorNames": ["website-contact-scraper"]
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['actorName']}: {item['grade']} ({item['overallScore']}/100)")
    for rec in item['recommendations']:
        print(f"  - {rec}")

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('UFM00vXOcr9bEMoHj').call({
    apiToken: 'YOUR_APIFY_TOKEN',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.actorName}: Grade ${item.grade} (${item.overallScore}/100)`);
    item.recommendations.forEach(rec => console.log(`  - ${rec}`));
});

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/UFM00vXOcr9bEMoHj/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "apiToken": "YOUR_APIFY_TOKEN",
    "actorNames": ["website-contact-scraper"]
  }'

# Fetch results from the dataset (use defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN"

How It Works

1. Actor discovery: Fetches all your actors using the Apify API (/v2/acts?my=true). If you specified actor names, filters to just those (case-insensitive matching).
2. Detail retrieval: For each actor, fetches full details including title, description, README, categories, pricing configuration, and icon URL.
3. Build inspection: Retrieves the latest tagged build to inspect the input schema (field count and descriptions) and dataset schema definition.
4. 10-point audit: Runs each actor through 10 weighted checks:
   • Title length (10 pts): Optimal range is 40-60 characters for Store search visibility
   • Description length (10 pts): Optimal range is 150-300 characters for search result snippets
   • README presence (15 pts): Highest-weighted check because README is the primary conversion tool
   • README length (10 pts): Target is 2000+ characters for comprehensive documentation
   • Categories (10 pts): At least one category must be assigned for Store discoverability
   • Pricing (10 pts): PPE pricing earns full points; other models earn partial credit
   • Input schema (10 pts): All fields should have descriptions for a good user experience
   • Dataset schema (10 pts): Defined schema lets users preview output structure in the Store
   • Custom icon (5 pts): Custom icons make actors stand out in search results
   • Example output (10 pts): JSON code blocks in the README help users understand what they get
5. Scoring and grading: Sums all check scores (max 100) and assigns a letter grade: A (90+), B (75-89), C (60-74), D (40-59), F (below 40).
6. Recommendations: Generates a prioritized list of actionable improvements based on failed and warned checks.
7. Output: Results are sorted worst-first and pushed to the dataset so you tackle the biggest problems first.

FAQ

Q: What Apify API token do I need? A: You need your personal Apify API token, which you can find at console.apify.com/settings/integrations. The token is used to read your actor metadata — it does not modify anything.

Q: Does this actor change my actor settings? A: No. This actor is completely read-only. It fetches metadata and generates a report. No settings, code, or configuration on your actors are modified.

Q: What score should I aim for? A: Aim for 90+ (Grade A). Actors with higher quality scores rank better in the Apify Store search results and are more likely to be adopted by users. The most impactful improvements are usually README quality and description length.

Q: How are the 100 points distributed? A: Title (10), Description (10), README presence (15), README length (10), Categories (10), Pricing (10), Input schema (10), Dataset schema (10), Icon (5), Example output (10). README-related checks account for 35 of 100 points because documentation is the strongest driver of adoption.

Q: Can I audit just one actor? A: Yes. Pass the actor name in the actorNames array, e.g., ["my-scraper"]. The name matching is case-insensitive.

Q: Why is my README getting a low score even though it exists? A: The auditor checks both presence and length separately. A README under 2000 characters will earn full marks for presence (15 pts) but only partial marks for length (5 pts for 500-2000 chars, 2 pts for under 500). It also checks for JSON example output in the README (10 pts).

Q: What counts as example output in the README? A: The auditor looks for JSON code blocks (triple backticks with json language tag). Having a code block with JSON content earns full marks. A section with "output" or "example" in the heading earns partial credit.

Q: How often should I run this audit? A: Run it after any significant changes to your actor metadata, README, or pricing. A monthly audit across your entire portfolio helps catch actors that have fallen behind as Store standards evolve.

Q: Why are results sorted worst-first? A: So you can immediately see which actors need the most attention. Fix the lowest-scoring actors first for the biggest impact on your overall Store presence.

Limitations

• Read-only -- this actor never modifies your actor settings, README, pricing, or metadata. All improvements must be applied manually.
• 10 checks only -- the audit covers 10 predefined SEO dimensions. Custom ranking factors specific to certain categories are not included.
• README inspection is text-based -- the auditor checks for JSON code blocks and output-related keywords. It does not evaluate writing quality, accuracy, or SEO keyword density.
• Latest tagged build only -- input schema and dataset schema checks use the latest tagged build. If your latest code changes are in an untagged build, they won't be reflected.
• No Store ranking prediction -- the audit score correlates with Store discoverability but is not a direct predictor of search ranking. Apify's ranking algorithm considers additional factors.
• Single run covers all actors -- pricing is per run, not per actor. This is cost-efficient for large portfolios but means a one-actor audit costs the same as a full-portfolio audit.

Integrations

• Zapier -- Trigger workflows when audit scores drop below a threshold. Send alerts to Slack or create tickets automatically.
• Make -- Build automated quality improvement workflows that track scores over time.
• Google Sheets -- Export audit results to Google Sheets for collaborative tracking and historical comparison.
• Apify API -- Call the actor programmatically. Integrate into CI/CD pipelines to audit actors after each deploy.
• Webhooks -- Receive notifications when audits complete.

Responsible use

• This actor only reads your own actor metadata using your Apify API token.
• It does not access other developers' actors, private data, or source code.
• Audit results are advisory. Use them as guidance for improving your Store listings.
• The token is used for read-only API calls and is not stored or transmitted outside the Apify platform.

Related actors

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.