Compare Web Crawlers for AI

Compare Crawl4AI and Apify crawls with a reusable AI quality scorecard.

Introduction

30 Second Summary

Two tools can read the same help page yet return very different details. A quick glance rarely reveals which result your next project can trust.

In this project, you will crawl the same 20 help pages with Crawl4AI on your laptop and Apify's Website Content Crawler in the cloud. You will compare speed, cost, and preserved details in a reusable Markdown scorecard.

What You'll Build

Your finished scorecard shows how both crawlers performed through measured speed, recorded cost, and fact-level quality checks.

By the end of this project, you'll have:

A local crawler that saves clean Markdown files for the help pages and reports the total crawl time.
A cloud crawler run that gives you an extracted dataset for the same pages and shows its cost in dollars.
A reusable quality checklist that tests whether important facts survived extraction. Its pass or fail table helps you compare matching pages without relying on document length.
Secret Mission: An optional challenge to extend your crawler comparison and push your evaluation skills further.

Are there any prerequisites?

You need Python installed on your computer and access to a terminal. You also need a free Apify account.

Before We Start

A fair crawler comparison depends on identical inputs. It also needs a local runtime that can complete the first crawl.

In this step, you prepare Python 3.10 or later in your terminal. You also confirm access to Apify Console before preparing the shared URL list.

In this step, get ready to:

Confirm that your terminal can run Python 3.10 or later.
Confirm access to your Apify Console account.
Prepare a local workspace with the shared 20-page URL list.

Confirm Python access

The local crawler runs through Python in your terminal. A version check confirms that your machine has a compatible runtime.

macOS

Press Cmd+Space to open Spotlight Search.
Type Terminal into the search field.
Press Enter to open Terminal.
Check the available Python version by running this command:

python3 --version

What does this command check?

The command prints the Python version available to your terminal. The project requires version 3.10 or later.

Windows

Press the Windows key to open Search.
Type PowerShell into the search field.
Press Enter to open PowerShell.
Check the available Python version by running this command:

py --version

What does this command check?

The command prints the Python version available through the Windows Python launcher. The project requires version 3.10 or later.

Choose the outcome below that matches the version check.

✔️ I see version 3.10 or higher

Your terminal can reach a compatible Python runtime. The local side of your crawler comparison is ready.

ⓧ I see an older version

Your installed Python version is below the required minimum. A current stable release gives the crawler the runtime it needs.

Visit the official Python downloads page.
Download a current stable installer for your operating system.
Run the downloaded installer.
Approve the operating system permission prompt after confirming the installer came from Python.org.
Close the terminal window used for the first check.
Reopen the terminal using the platform steps above.
Repeat the version check for your platform.

You should now see Python 3.10 or later in the result.

ⓧ Command not found

Your terminal cannot reach Python yet. Installing a current stable release adds the required runtime.

Visit the official Python downloads page.
Download a current stable installer for your operating system.
Run the downloaded installer.
Approve the operating system permission prompt after confirming the installer came from Python.org.
Close the terminal window used for the first check.
Reopen the terminal using the platform steps above.
Repeat the version check for your platform.

You should now see Python 3.10 or later in the result.

Still cannot reach Python?

A terminal opened before installation may not detect the new program. Close every terminal window before repeating the check.

If a fresh terminal still cannot find Python, help me connect my terminal to Python.

Sign in to Apify Console

Apify Console hosts the cloud crawl that you compare with the local results. Reaching its Dashboard confirms that your cloud workspace is available.

Your sign-in details stay on Apify's authentication page. You never paste your password into this project.

✔️ I have an Apify account

Visit the official Apify Console sign-in page.
Complete the sign-in flow using the authentication method connected to your account.

You should reach the Apify Console Dashboard. This confirms that your cloud workspace is ready.

ⓧ I need an Apify account

Visit the official Apify Console sign-up page.
Choose an available account creation method.
Complete the authentication prompts for your chosen method.
Open the verification email if Apify requests email verification.
Follow the verification link to finish creating your account.

You should reach the Apify Console Dashboard after authentication. This confirms that your new account is ready.

That clears the cloud-access hurdle. You can now reach the workspace that runs the hosted crawler.

Cannot reach the Dashboard?

Check your inbox for an Apify verification message. An unverified account may return to the verification flow.

If access still fails, help me troubleshoot Apify Console access.

Prepare the shared URL list

Both crawlers need the same pages for a fair comparison. Your first URL becomes the smaller test case for the initial local crawl.

macOS

Create the crawler-comparison workspace on your Desktop by running these commands in the terminal:

cd ~/Desktop
mkdir crawler-comparison
cd crawler-comparison
pwd

What do these commands create?

The commands create the crawler-comparison directory on your Desktop. The final command prints its location.

You should see a path ending in Desktop/crawler-comparison.

Windows

Create the crawler-comparison workspace on your Desktop by running these commands in PowerShell:

Set-Location -Path $([Environment]::GetFolderPath('Desktop'))
New-Item -Path "crawler-comparison" -ItemType Directory
Set-Location -Path "crawler-comparison"
Get-Location

What do these commands create?

The commands create the crawler-comparison directory on your Desktop. The final command prints its location.

You should see a path ending in Desktop\crawler-comparison.

Workspace directory already exists?

An existing directory with the same name can stop the creation command. Use it only if it is empty.

If you need help resolving the conflict, help me create the crawler comparison workspace.

The target list stores one public help-page address per line. Keeping all 20 pages in one text file gives both crawlers an identical input.

Choose one public help center with at least 20 accessible help pages.
Collect 20 unique help-page URLs from that help center.
Select one page with detailed instructions for the initial test crawl.
Record the selected page as your initial help-page URL.

Choose useful test pages

Include pages with conditional instructions. Include pages with nested sections.

These details give your later quality checklist specific facts to test.

macOS

Press Cmd+Space to open Spotlight Search.
Type TextEdit into the search field.
Press Enter to open TextEdit.
Click Format in the menu bar.
Select Make Plain Text.

Your blank document is now ready to store one URL per line.

Place your initial help-page URL on the first line.
Enter the remaining 19 URLs on separate lines.
Press Enter after the final URL.
Click File in the menu bar.
Click Save.
Enter target-urls.txt as the file name.
Select the crawler-comparison directory on your Desktop as the save location.
Click Save to create the file.

Windows

Press the Windows key to open Search.
Type Notepad into the search field.
Press Enter to open Notepad.

Your blank document is ready to store one URL per line.

Place your initial help-page URL on the first line.
Enter the remaining 19 URLs on separate lines.
Press Enter after the final URL.
Click File in the menu bar.
Click Save As.
Select the crawler-comparison directory on your Desktop as the save location.
Enter target-urls.txt in the File name field.
Click Save to create the file.

Before you count the file, what number do you expect the terminal to report?

Switch back to the terminal from your workspace setup.
Count the URL lines by running the command for your platform:

macOS

wc -l target-urls.txt

What does this command count?

The command counts the lines in target-urls.txt. One URL per line makes the result equal to the number of crawl targets.

Windows

(Get-Content -Path "target-urls.txt").Count

What does this command count?

PowerShell reads each line of target-urls.txt as one item. The count reports the number of crawl targets.

You should see 20 in the result. The first line holds your designated initial test URL.

Count does not show 20?

Remove blank lines from target-urls.txt.
Add any missing help-page URLs.
Remove duplicate URLs.
Save target-urls.txt before repeating the count.
Use help me fix my target URL count if the total still looks wrong.

Return to the Apify Console browser tab from earlier.

You should still see the Apify Console Dashboard. This confirms that both sides of your crawler comparison are available.

Your setup is complete. The local workspace now holds the same 20-page input that the cloud crawler uses later.

Your shared input is ready. Next, Crawl4AI turns the first URL into clean local output.

Crawl One Page Locally

A fair crawler comparison starts with one page that both tools can reach. The local result becomes the baseline for every later test.

In this step, you will install Crawl4AI with its browser dependencies. You will run one help page through the crawler to print clean Markdown in your terminal.

In this step, get ready to:

Install Crawl4AI in your local Python environment.
Set up the required browser dependencies.
Print clean Markdown from the designated help page.

Prepare the crawler runtime

Crawl4AI uses a headless browser to load a page before extracting its content. This allows the local crawler to process help pages that rely on browser rendering.

The one-time browser download is the slowest part of this setup. It can take a few minutes while progress continues in the terminal.

Switch back to the terminal for your local project workspace.
Install Crawl4AI with its required browser dependencies by running these commands:

pip install -U crawl4ai
crawl4ai-setup

What do these commands do?

The pip command installs or upgrades the Crawl4AI package in your current Python environment.
The crawl4ai-setup command downloads the browser components that Crawl4AI controls during a crawl.

You'll see package installation messages first. You'll then see the browser setup complete its checks.

The heavy setup is finished: Crawl4AI now has a browser it can control.

Browser setup not completing?

Confirm the terminal is using the local Python environment for this project.
Run the browser setup again if the download was interrupted.
Check your network connection if the download stops without making progress.

Help me fix my Crawl4AI browser setup.

Prove the local extraction path

Crawl4AI includes a command-line interface for sending one URL through the local crawler. Its Markdown output lets you inspect the extracted page content directly in the terminal.

Copy the designated test help-page URL from your prepared list into this value: your designated test help-page URL.

Before you run the crawl, which output do you expect to see: raw page markup or readable Markdown?

Send the designated help page through your local crawler by running this command:

crwl [[TEST_URL="your designated test help-page URL"]] -o markdown

What does this command do?

The crwl command starts a local Crawl4AI crawl.
The URL identifies the single help page used for this baseline test.
The -o option with the markdown value prints the extracted page content as Markdown.

You'll see readable headings, paragraphs, lists, and links from the help page in your terminal. The output should contain wording you can recognize from the original page.

That is your first local baseline complete: the designated help page now survives the trip from website to Markdown.

No page content in the terminal?

Copy the complete URL from your prepared list again if the crawler cannot reach the page.
Confirm the same page loads in your normal browser to rule out a network or website problem.
Run the browser setup again if the terminal reports a missing browser dependency.

Help me troubleshoot my first Crawl4AI crawl.

Your local crawler can now turn one help page into readable Markdown. Next up, you will run the same process across all 20 target URLs.

Crawl the URL List with Crawl4AI

Your first Crawl4AI result proved that the designated help page can become clean Markdown.

A fair comparison needs all 20 target pages processed through the same local flow. This step saves each successful extraction as a separate file before recording the total batch duration.

In this step, get ready to:

Extend the successful one-page crawl to the prepared 20-URL list.
Save one Markdown file for each successful local crawl.
Record the total elapsed time for the complete local run.

Turn the one-page test into a batch

A batch crawl applies one extraction flow to several URLs. A unique file for each result keeps every local page traceable during the later comparison.

Switch back to the terminal from your successful single-page Crawl4AI test.
Update the successful one-page flow so it saves the extracted Markdown in a dedicated output folder inside the current project workspace. Use a unique .md filename that maps back to the source URL.
Save the updated local crawl flow.

Before you run this check, predict whether the saved file will preserve the same clean content you saw in the terminal.

Run the updated flow against the designated test help page again.

When the request succeeds, you should see one uniquely named Markdown file in the dedicated output folder. Its content should match the clean extraction from your earlier terminal test.

Inspect the dedicated output folder from your project workspace view.
Open the saved Markdown file for the designated test page.

You have the save path working now. Each successful page can land in a traceable local file.

Change the batch input to the first two entries from the prepared 20-URL list.
Save the two-URL batch configuration.

Before you run the batch, predict how many Markdown files the output folder should contain when both requests succeed.

Run the two-URL batch in the same local environment.

When both requests succeed, you should see two uniquely named Markdown files in the output folder. Each file should map to one of the two source URLs.

Why use separate files?

Each file represents one source page. That stable pairing lets you compare the local extraction with the matching Apify dataset item later.

Missing one of the test files?

Check that both batch entries exactly match URLs from the prepared target list.

Confirm the save step runs after a successful extraction. Also confirm each page receives a different filename.

Help me find why my two-URL Crawl4AI batch did not save one Markdown file per successful page.

Time the complete local crawl

A fair timer starts immediately before the first target begins processing. It stops after the last successful extraction has been saved.

Update the batch flow to process the complete prepared 20-URL list inside one elapsed-time measurement. Make the final summary report the saved-file count plus the total duration.
Save the timed 20-URL batch configuration.

The full batch takes longer than the two-page check. A quiet terminal can still mean the browser is working through a page.

Before you start the full run, predict the number of Markdown files you will have if every target succeeds.

Run the timed batch from the same local environment.

When the run finishes, you should see a final summary with the saved-file count plus the total elapsed time. A fully successful run should report 20 saved files.

Copy the printed total duration into a timing note stored with the local crawl results.
Count the Markdown files in the dedicated Crawl4AI output folder.
Compare the folder count with the saved-file count from the final summary.
Open the file mapped to the designated test page.

The two counts should match. The designated test page should still contain the clean Markdown details from the original single-page crawl.

Do the file counts differ?

Check that every target URL maps to a unique filename. Duplicate filenames can overwrite earlier pages.

Compare the prepared URL list with the saved filenames to identify missing targets. Fix the affected input before repeating the complete timed run.

Help me diagnose why my Crawl4AI summary count differs from the number of saved Markdown files.

Your local baseline is captured. Next, you will run the same 20 URLs in Apify to collect the cloud results.

Run the Apify Crawler

Your local Crawl4AI run already produced Markdown for 20 help pages. It also gave you a total crawl time.

A fair comparison needs the cloud crawler to receive the exact same list. Any extra discovered pages would distort the comparison.

The Apify Website Content Crawler is a hosted Actor. It stores extracted pages in a dataset.

You will record its run duration. You will also record its displayed cost.

In this step, get ready to:

Configure the Actor with the same 20 help-page URLs.
Run the cloud crawl to produce its dataset.
Record the completed run metrics.

Configure the same 20 URLs

Start URLs define the pages the Actor fetches. A maximum crawl depth of 0 stops links on those pages from expanding your test set.

This console workflow uses your existing Apify account. You do not need to paste a token into the project.

Visit the official Website Content Crawler page.
Sign in to Apify Console if prompted.
Select Input to open the run configuration.
Switch back to the prepared target URL list from earlier.
Add all 20 URLs under Start URLs with one URL per item.

Your input should now show 20 entries under Start URLs.

Set the maximum crawl depth input named maxCrawlDepth to 0.
Set the maximum pages input named maxCrawlPages to 20.

The configuration now limits the run to your supplied pages. The 20-page ceiling also prevents an accidental crawler runaway.

Enable Save Markdown if its switch is off.

The output settings should now show Markdown saving as enabled.

Keep the Run Capped

The Actor itself is free to use. Apify charges for the platform usage it consumes.

The Free plan includes $5 in monthly credits. The 20-page cap keeps this comparison deliberately small.

Run the cloud crawl

An Actor run turns the saved input into a cloud job. Apify writes each successful extraction to the run dataset.

This cloud run can take a few minutes while Apify starts its workers. A short wait here is normal.

Before you start the run, do you expect its output count to exceed the 20-page cap?

Click Start.
Keep the run detail page open until the crawl finishes.

You should see the run finish successfully. The Output tab should now be available.

Select Output to view the dataset.
Open one result record from the dataset.

You should see extracted page records in the dataset. A successful record includes its url plus extracted content in markdown.

Missing Pages or Markdown?

Review the run log for requests that did not complete.
Confirm the input still contains 20 Start URL items when records are missing.
Enable Save Markdown before rerunning when extracted Markdown is absent.

Ask for help with finding missing Apify dataset records.

Record the run metrics

Run duration measures the cloud job from start to finish. The displayed cost captures the platform usage charged for that run.

Return to the completed run detail page.
Open Usage info.
Record the duration shown beside Finished as your Apify run duration.
Record the displayed US dollar cost as your Apify run cost in US dollars.

Before the final check, do you expect the completed run to show both extracted records and usage metrics?

Select Output to confirm the designated test help page appears in the dataset.
Return to the run details to confirm the duration is visible.
Check that the displayed cost is visible in US dollars.

You should now see a completed run with extracted records for the target list. The same run details should show its duration plus its displayed cost.

That completes the cloud half of your benchmark. You now have the evidence needed for a crawler comparison.

Your Apify crawl is complete. Next up, you will export its dataset and line one cloud result up with its Crawl4AI match.

Export and Match the Results

Both crawler runs now cover the same target list. Your Crawl4AI files already hold the local extraction.

The Apify Website Content Crawler records still sit in a cloud dataset. A page-by-page comparison needs both outputs in one workspace.

A source URL gives each pair a shared identity. You will use that key to build the mapping before opening one matched page.

In this step, get ready to:

Export the Apify dataset into your local project workspace.
Match each local file to its exported Apify record by source URL.
Review one matching page from both crawlers side by side.

Export the Apify dataset

An Apify dataset stores each extracted page as a separate item. A JSON export preserves those items for local inspection.

Return to the completed Website Content Crawler run in Apify Console.
Select the Storage tab on the run page.
Select the dataset produced by the completed run.
Select Export.
Choose JSON as the export format.
Leave Select fields empty.
Leave Omit fields empty.
Select Preview.

You will see a preview containing one object per exported page. The objects retain the fields needed for matching.

Verify that the url field appears in the preview.
Verify that the markdown field appears in the preview.
Select Download.
Move the downloaded JSON file from your Downloads folder into the project workspace from earlier.
Rename the exported file to apify-results.json.
Double-click apify-results.json in the project workspace to inspect it.

Good progress. The cloud crawl now sits beside your local results with each source URL intact.

Missing the URL or Markdown field?

Return to Export.
Clear every value from Select fields.
Clear every value from Omit fields.
Select Preview again.

If the fields are still absent, help me inspect my Apify dataset export.

Match records by source URL

The target URL list can become your mapping table. Each row connects one source URL to its local file plus its exported Apify record.

Return to the target URL list from earlier.
Add a field named Crawl4AI file beside each URL.
Add a field named Apify record beside each URL.
Copy the first source URL from the list.
Switch back to the local Crawl4AI markdown folder from earlier.
Find the markdown file produced for that source URL.
Record the local filename in the matching Crawl4AI file field.
Switch back to apify-results.json.

The first half of your mapping now points from a source URL to its local extraction.

Press Cmd+F on macOS or Ctrl+F on Windows to open search.
Paste the copied source URL into the search field.
Confirm that one exported object contains the exact URL in its url field.
Record Matched in the corresponding Apify record field.
Repeat the URL lookup for the remaining 19 target URLs.
Record Missing in Crawl4AI for any URL without a local file.
Record Missing in Apify for any URL without an exported object.
Save the updated target URL list in the project workspace.

You should now have one mapping entry per target URL. Every successful pair points to a local filename plus an Apify record with the same source URL.

Why match on URL?

Unrelated pages can produce outputs of similar length. The source URL anchors both extractions to the same page. This gives the later quality checks a fair starting point.

Can't find a URL match?

Compare the domain in both URL values.
Compare the path in both URL values.
Keep the row marked with the appropriate missing status when the exact source URL remains absent.

For help tracing a mismatch, help me compare these crawler URLs safely.

Review one page side by side

One complete pair proves that the mapping reaches both outputs. This check focuses only on page identity.

Choose any mapping entry marked Matched.
Open its local Markdown file from the project workspace.
Return to apify-results.json.
Open search with Cmd+F on macOS or Ctrl+F on Windows.
Search for the exact source URL from the matched entry.
Position the local file beside the matching exported object.

Before you check this pair, do you expect both views to represent the same help page?

Read the source URL in the mapping entry.
Confirm that the exported object's url value matches it exactly.
Compare the opening heading or sentence in both extracted outputs.

You will see two extractions from the same help page side by side. The mapping now gives you a representative pair for the next comparison.

You have the alignment work done. Your next quality scores now start from a fair comparison.

Do the pages look unrelated?

Return to the matching entry in the updated target URL list.
Confirm that the open local filename appears on that entry.
Search the exported JSON again using the complete source URL.

If the pair still looks wrong, help me correct my crawler result mapping.

Your two crawls are now aligned. Next, you will test whether specific facts survived each extraction.

Check Extraction Quality

You already lined up matching Crawl4AI output with Apify's Website Content Crawler output for the same help page. That comparison gives you the evidence needed to measure extraction quality.

A long extraction can still lose a condition that changes the meaning of an answer. This step turns required facts into repeatable pass-or-fail checks for an AI system.

In this step, get ready to:

Define a fact checklist that includes conditional instructions.
Build a local script that checks both matched outputs.
Produce a per-page pass-or-fail quality table.

Define the fact checklist

A quality checklist replaces a visual judgment with evidence. Each checklist entry ties one source URL to one fact that must survive extraction.

Switch back to the representative matching page from the previous step.
Use its source URL to view the original help page.
Create the reusable quality checklist inside the project workspace from earlier.
Record the source URL as the first checklist entry.
Add the complete wording of one conditional instruction to that entry.
Add the complete wording of one required action to that entry.
Add the complete wording of one expected result to that entry.
Repeat this fact selection for every matched page in the target list.

Why Facts Beat Length

Text length measures how much content survived. A fact check measures whether the useful meaning survived.

Conditional instructions are especially revealing because a missing condition can turn correct guidance into a wrong answer. The same checklist keeps both crawlers accountable to the same standard.

Build the quality checker

The quality check script applies one checklist fact to the corresponding output from each crawler. It returns a separate pass-or-fail result for each extraction.

Return to the project workspace from earlier.
Create a local quality check script that evaluates the representative matched pair against one checklist entry.
Run the quality check script against that representative pair from the same local Python environment.

You should see one quality row for the selected page. The row should contain the checklist fact plus a result for each crawler.

What Makes the Check Fair?

Both crawlers receive the same source URL plus the same required fact. A pass means the extraction preserved that fact.

A missing fact produces a fail. A missing crawler output also produces a fail because skipped pages cannot support an AI answer.

No Result Row?

Confirm that the representative page has an entry in the URL match mapping. Check that the checklist entry uses the same source URL.

If both outputs load but no result appears, trace the part of the script that creates the result row.

Help me troubleshoot my quality check script.

Extend the script to evaluate every entry in the quality checklist.
Make the script assign a failed result when either crawler has no matched content.

Run the full quality check

The full run converts your checklist into a page-by-page comparison. Every row should expose the exact fact being tested plus the result from each crawler.

Before you run the complete check, which crawler do you expect to preserve more of the required facts?

Run the completed quality check script from the same local Python environment.

You should see a per-page table with one row for every checklist fact. Each row should show separate pass-or-fail results for Crawl4AI and Apify.

Confirm that every matched source URL appears in the table.
Confirm that every required fact has a Crawl4AI result.
Confirm that every required fact has an Apify result.
Compare one failed result with its original source page.
Keep the quality results table for the final scorecard.

Missing Pages or Checks?

Check whether each absent page exists in the URL match mapping. A skipped extraction should remain visible as a failed result.

If a fact is missing from both result columns, confirm that its checklist entry includes the correct source URL.

Help me find missing quality results.

You have turned extraction quality into evidence you can defend. Next, you will combine these results with the recorded time plus cost in the final scorecard.

Generate the Crawler Scorecard

Your matched outputs already show what Crawl4AI preserved across the 20 help pages. They show the same evidence for Apify.

A Markdown scorecard brings time, cost, and quality into one view. It gives you a repeatable way to choose a crawler from evidence.

In this step, get ready to:

Set the scope for the 20-URL comparison.
Compare crawl time plus cost for both crawlers.
Add the quality outcomes to the completed scorecard.

Set the scorecard scope

A reusable scorecard needs a clear test boundary. The scope records the 20-page target list plus the shared quality checklist.

Return to the file editor that contains your quality checklist script from earlier.
Create crawler-scorecard.md inside the same local project workspace.

You should see a blank crawler-scorecard.md file in your editor. This confirms the scorecard sits beside the reusable comparison tools from earlier.

Add a title that identifies the file as the crawler comparison scorecard.
Save crawler-scorecard.md.

Your rendered preview should now show a clear scorecard title.

Add a scope section that states the comparison covers the same 20 help-page URLs.
Save crawler-scorecard.md.

Good start. Your scorecard now records the exact boundary for every result that follows.

Compare time and cost

Matching recorded values to the correct crawler can feel fiddly. A two-row table keeps every figure attached to its source.

Populate a two-row comparison table in crawler-scorecard.md. Use columns for crawler, crawl time, and cost. The Crawl4AI row uses the recorded total local duration. Its cost entry describes local compute with no library licence fee. The Apify row uses the recorded run duration plus the displayed cost in US dollars.
Save crawler-scorecard.md.
Open a rendered preview of crawler-scorecard.md in your editor.

You should see one row for Crawl4AI. You should also see one row for Apify.

Each row should show the timing plus cost evidence you recorded during its crawl.

Why keep the cost wording precise?

Crawl4AI runs on your laptop without a library licence fee. Your machine still provides the compute used by the local crawl.

The Apify row captures the direct run cost displayed in the Console. This wording keeps two different cost models clear.

Add quality results and decide

Speed plus cost only describe how the crawlers performed the work. The quality results show whether each extraction preserved the facts an AI system needs.

Build a quality section in crawler-scorecard.md from the existing quality results table. Its summary reports pass and fail totals for each crawler. Its detail reproduces the per-page outcomes.
Save crawler-scorecard.md.
Open the rendered preview to check the new quality section.

You should see quality outcomes for both crawlers. The results should trace back to the same checklist used on the matched pages.

Write a conclusion section in crawler-scorecard.md. The conclusion identifies the leader or tie for crawl time. It records the result for direct cost. It also records the result for extraction quality. A final reuse note names the inputs to replace for another URL list.
Save crawler-scorecard.md.

Before you check the final file, which crawler do you expect the combined evidence to favour?

Open the rendered preview of crawler-scorecard.md.

Your rendered file should show the title plus the 20-URL scope. It should also show both crawler rows with their recorded time plus cost evidence.

The quality section should show the pass-or-fail outcomes from the existing results table. The conclusion should name the result for every comparison category.

✔️ My scorecard is complete

Your scorecard contains the scope, crawl metrics, quality outcomes, and evidence-based conclusion for the 20-URL list.

ⓧ I need to double check

Confirm the scope states that both crawlers used the same 20 help-page URLs.
Confirm each crawler has its recorded crawl time plus cost entry.
Confirm the quality section contains pass-or-fail outcomes for each crawler.
Confirm the conclusion identifies a leader or tie for every category.

Scorecard missing a result?

Compare the scorecard rows with the recorded timing values from earlier.
Check the Apify cost entry against the displayed run cost you recorded.
Check the quality section against the per-page results table.

help me trace a missing scorecard value back to the existing crawler records.

That completes the comparison. You now have a reusable scorecard grounded in the same URLs plus the same quality checks.

Secret mission

Add Scenario-Based Recommendations

Turn your crawler benchmark into a decision tool for different project priorities. Add evidence-backed recommendations for teams that care most about cost, speed, or extraction quality.

Clean Up Your Resources

Your local project files have no ongoing cost. The completed hosted run has already recorded its cost against your Apify account credit.

Resources you used:

Local project workspace containing the Crawl4AI environment, target URL list, local extractions, exported dataset, URL mapping, timing record, quality checklist, quality check script, results table, and reusable Markdown scorecard.
Apify Website Content Crawler dataset containing the extracted page records from the completed 20-URL run.

Keep everything running

No action is needed. Choose this option if you want every result available for future crawler comparisons.

Keep the local project workspace so you can reuse the scorecard with another URL list.
Keep the quality checklist so you can test the details another AI project needs.
Keep the quality check script so you can repeat the comparison.
Keep the Apify dataset so you can review its extracted page records in the Apify Console.
Compare the recorded run cost with the credit shown in your Apify account to confirm that the run stayed inside the available monthly credit.

Pause - I'll come back to this later

No crawler run is active. This option keeps your local files and hosted records ready for your next comparison.

Keep the local project workspace in its current location.
Leave the completed Apify dataset available in the Apify Console.
Compare the recorded run cost with the credit shown in your Apify account to confirm that the run stayed inside the available monthly credit.

Delete - I don't want to use this again

Remove the crawler data if you no longer need it. Preserve the reusable comparison tools first so you can apply the same process to another URL list.

Copy the crawler comparison scorecard to a directory outside the local project workspace.
Copy the quality checklist to the same directory.
Copy the quality check script to the same directory.
Return to the Apify dataset produced by the completed Website Content Crawler run.
Use the deletion control on that dataset page to delete the extracted page records.
Confirm that the dataset from the completed run is no longer available in the Apify Console.
Compare the recorded run cost with the credit shown in your Apify account to confirm that the run stayed inside the available monthly credit.

macOS

Find the local directory used as the project workspace in Finder.
Move the project workspace directory to the Trash.
Empty the Trash to remove the Crawl4AI environment, local crawler outputs, and exported Apify records.

Windows

Find the local directory used as the project workspace in File Explorer.
Move the project workspace directory to the Recycle Bin.
Empty the Recycle Bin to remove the Crawl4AI environment, local crawler outputs, and exported Apify records.

Linux

Find the local directory used as the project workspace in your file manager.
Move the project workspace directory to your system trash.
Empty the system trash to remove the Crawl4AI environment, local crawler outputs, and exported Apify records.

Nice Work!

Great job! Your reusable Markdown scorecard now compares Crawl4AI with Apify's Website Content Crawler across the same 20 help pages.

You've learned how to:

Run a controlled crawler comparison against one shared URL list.
Match extracted pages by source URL. Check each page with a reusable fact checklist.
Generate a reusable Markdown scorecard that compares crawl time, cost, and quality results.
Secret Mission: Take on an optional challenge to push your crawler comparison skills further.

Ready to quiz yourself?