Apify Tutorial: How to Use Apify for Web Scraping (Step by Step)

This is how we actually use Apify at MaxSun Media: pull marketplace and trend data, build lead lists for a specific market, and run the whole thing on a schedule with a hard cap on what it can spend. No theory, no "10 best scrapers" roundup. One tool, the real workflow, and the settings that keep a scrape from quietly draining a budget.

If you have never scraped anything before, Apify is the gentlest on-ramp I have found, because you do not have to write a scraper to get data out of it. You rent one that already works. Here is the whole loop, start to finish, and where it sits in the stack we run on.

What Apify actually is

Apify is a cloud platform for running web scrapers. The scrapers are called actors — small programs that open a site, read it, and write the results into a dataset you can download. You do not have to build one. The Apify Store has thousands of ready-made actors for the sites people actually scrape: Google Maps, Amazon, Instagram, TikTok, Google Search, generic "crawl this website" actors, and a long tail of niche ones.

Two ideas make everything else click:

• Actor — the scraper itself. You give it input, it produces output. You can run someone else's or write your own.
• Dataset — where a run's results land. Every run gets its own dataset you can export as JSON, CSV, or Excel, or pull through the API.

That is the mental model. Pick an actor, feed it input, read the dataset. The rest is detail.

Before you start: the one setting that matters

Make a free account first. You land on a console with the Store, your actors, runs, schedules, and storage. Before you run anything, go set spend limits. This is the step most tutorials skip and the one that matters most, because Apify bills by usage. An actor pointed at a big site can run far longer than you meant it to.

In your account settings there is a usage limit — a hard monthly ceiling. Set it. On our account it is set low on purpose. If a scrape goes sideways, it stops at the cap instead of eating the month. We treat that number as a seatbelt, not a suggestion.

Step 1: Pick an actor

Open the Store and search for the site you want. For a concrete example, say we want a list of businesses in a market — the kind of lead list we build before an outreach campaign. Search "Google Maps", pick a well-reviewed scraper, and open it. Look at run count, rating, and when it was last updated: a stale actor breaks the day the target site changes its markup.

Every actor page has a Readme and an Input tab. Read the Readme once. It tells you what the actor expects and what it returns. Ten minutes here saves an hour later.

Step 2: Configure the input

The Input tab is a form. For a maps scraper it is usually search terms, a location, and a cap on results. Fill it in like a person searching, then set the result cap low for a test run — 10 or 20 items — so you can confirm the output looks right before you ask for thousands.

Under the hood that form is just JSON. Most actors let you flip to a JSON view, which is what you use once you automate. For a maps-style actor it reads about like this:

{
  "searchStringsArray": ["hardscape contractor"],
  "locationQuery": "Scottsdale, Arizona",
  "maxCrawledPlacesPerSearch": 20,
  "language": "en"
}

Run the test. Look at the first few rows. Are the fields you need actually there: name, phone, website, address? If yes, scale the cap up. If not, fix the input or try a different actor now, while it is cheap.

Step 3: Cap the run before you scale

Before you turn 20 into 2,000, set the per-run guardrails. On the run options you can set memory, a run timeout, and a max number of items. The one we care about most is the per-run charge limit — the most this single run is allowed to cost. Between that and the monthly usage cap from earlier, a runaway scrape has two brakes.

When we run through the API, those limits are explicit parameters. In the Python client it reads like this:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("compass/crawler-google-places").call(
    run_input={
        "searchStringsArray": ["hardscape contractor"],
        "locationQuery": "Scottsdale, Arizona",
        "maxCrawledPlacesPerSearch": 2000,
    },
    memory_mbytes=2048,
    max_total_charge_usd=5,   # this run cannot cost more than $5
)

That max_total_charge_usd line is the whole point. It is the difference between a scrape you control and one that controls your invoice.

Step 4: Run it, then put it on a schedule

You can hit Start and watch it run. That is fine for a one-off. But the reason Apify earns a spot in the stack is scheduling. We do not scrape by hand. We set a Schedule — Apify's built-in cron — so the lead list or the trend snapshot refreshes on its own.

Create a Schedule, attach the actor (or a saved task with your input baked in), and give it a cron expression. Weekly, before the Monday planning pass, looks like this:

0 6 * * 1   # 06:00 every Monday

Now the data is waiting for you instead of being a chore you have to remember. The spend caps still apply on every scheduled run, so "set and forget" does not turn into "set and overspend".

Step 5: Export the dataset

When a run finishes it has a dataset. Three ways to get it out, depending on what you are doing:

• From the console — open the run, hit Export, choose CSV or JSON. Good for a quick pull.
• Straight from the API — every dataset has an ID and a URL. This grabs the items as CSV:

curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<YOUR_APIFY_TOKEN>"

• In code — if you already ran the actor from the client, the items are one loop away:

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["title"], item.get("phone"), item.get("website"))

That is the loop we run. An actor pulls the raw list, the dataset comes back as structured rows, and everything downstream — dedupe, verify, enrich — happens on our side. Apify's only job is turning "go find out" into a clean dataset.

How this sits in the pipeline

Two jobs, same tool. One is lead lists: a market, a category, a scheduled scrape, a CSV we verify before anyone gets an email. The other is trend data: before we build a video or a campaign around a niche, we scrape what is actually moving in it so we are producing into real demand, not a guess. That second job feeds straight into how we research video topics with vidIQ.

Pricing, an honest take

Apify bills on usage, not seats. There is a free tier with monthly credit that is genuinely enough to learn the tool and run small jobs. Paid plans raise the monthly credit and unlock more concurrency and proxies. Renting a popular actor may add its own small per-result or monthly fee on top, which the actor page states up front.

The honest version: the sticker price is not the risk. Usage is. A cheap plan with a careless scrape can cost more than an expensive plan with disciplined caps. That is why we lead with the limits and not the tier. Set the monthly ceiling, set the per-run charge cap, and the pricing becomes predictable. Check their pricing page for the current numbers — they move, and I would rather you read the live figure than trust a stale one from a blog post.

Verdict

If you need data off the web and you are not in the business of maintaining scrapers, Apify is the shortest path from question to dataset. Rent an actor, cap the spend, schedule it, export it. We keep it in the stack because it does one thing we rely on: it makes web data boring and repeatable, and it never gets to surprise us on cost.

When you have the data, the next question is what to make with it. That is where the rest of the stack comes in, and where we deploy whatever we build, on Netlify.

Frequently asked questions

Is Apify free?

There is a free plan with a monthly usage credit. It is enough to learn the tool, run small scrapes, and follow this whole walkthrough. You only pay when your usage outgrows the free credit, and even then you set the ceiling.

Do I need to know how to code to use Apify?

No. You can pick an actor from the Store, fill in a form, click Start, and export a CSV without writing a line. Code only comes in when you want to automate, like running on a schedule or pulling the dataset straight into your own scripts.

What is an actor in Apify?

An actor is a scraper packaged as a program. It takes input (what to scrape) and produces output (a dataset). You can run actors other people built or write your own; most people start by renting existing ones.

How do I stop Apify from overcharging me?

Two settings. A monthly usage limit on your account caps total spend, and a per-run charge limit caps any single run. Set both low while you learn. A scheduled scrape then refreshes data without any risk of running past the number you chose.