How to Run Bulk Keyword Research with DataForSEO APIs

When teams need a bulk keyword research workflow, there are usually two ways to get there: stitching together GUI exports or integrating a keyword research API. Our Keyword Data API and DataForSEO Labs API both offer endpoints that accept up to 1,000 keywords per request. For instance, with Google Ads Live endpoints capped at 12 API requests per minute per account, that puts the ceiling at roughly 720,000 keywords per hour from a single endpoint. This article will explain which endpoint to use for which job, how to combine them, and how to scale.

Why run bulk keyword research with an API

Google’s keyword tools are built around a UI and primarily designed for manual use in a browser. Keyword Planner caps the number of suggestions you can retrieve, slows down repeated lookups, and bundles related terms into rough search volume ranges. The Search Console interface returns at most a few hundred query rows for a property at a time. That works for small projects, but past a few hundred keywords, the manual workflow with these tools breaks. You spend more time exporting, deduplicating, and rejoining CSVs than reading and analyzing the data.

An API skips that loop. One POST request returns structured JSON for hundreds of keywords with the same fields the interface gives you, plus historical depth it doesn’t expose. For a team building a keyword research feature, the cost changes a lot: per-batch latency goes from minutes to seconds, and, once integrated, the API workflow runs on a schedule instead of regularly taking someone’s whole afternoon.

But once you’ve decided to use an API, the next question is which endpoint to use for each part of the workflow.

Which DataForSEO API endpoint to use for which keyword research task

Keyword Data API and the DataForSEO Labs API are both designed for advanced keyword research workflows, but they work best for different parts of it. Keyword Data API focuses on metrics pulled straight from the source: Google Ads, Bing Ads, and clickstream-derived data. DataForSEO Labs API delivers additional metrics like keyword difficulty and search intent that we calculate based on our keyword and SERP databases. Here’s the endpoint cheat sheet for bulk workflows:

A common practice is to enrich one keyword list across several endpoints in a single workflow. Start with Google Ads Search Volume for CPC and competition. Then send the same list to Bulk Keyword Difficulty to score how hard it is to rank for each keyword. Finally, run it through Search Intent to label if the term fits informational, commercial, or transactional content. By the end, every keyword in your dataset has six to eight metrics attached, built from three bulk API calls instead of multiple one-by-one queries.

Step-by-step: pull search volume for 1,000 keywords in bulk with one API call

Let’s consider the Live Google Ads Search Volume endpoint in our Keyword Data API for an example bulk workflow. It supports up to 1,000 keywords per request and returns Google Ads metrics for each term in a single response. The snippet below sends three keywords for the US locale. To use it with your own data, just swap in your own 1,000-keyword list in the array.

# Use your credentials from https://app.dataforseo.com/api-access
login="login"
password="password"
cred="$(printf ${login}:${password} | base64)"

curl --location --request POST \
  "https://api.dataforseo.com/v3/keywords_data/google_ads/search_volume/live" \
  --header "Authorization: Basic ${cred}" \
  --header "Content-Type: application/json" \
  --data-raw '[
    {
      "location_code": 2840,
      "language_code": "en",
      "keywords": ["buy laptop", "cheap laptops for sale", "purchase laptop"],
      "search_partners": true
    }
  ]'

See the Live Google Ads Search Volume docs for details.

The response of the API call above returns structured JSON data with one object per keyword in the result array. Here’s the structure trimmed to the fields you’ll use most:

{
  "status_code": 20000,
  "tasks": [
    {
      "result": [
        {
          "keyword": "buy laptop",
          "location_code": 2840,
          "language_code": "en",
          "search_volume": 33100,
          "competition": "HIGH",
          "competition_index": 100,
          "cpc": 1.42,
          "low_top_of_page_bid": 0.55,
          "high_top_of_page_bid": 2.31,
          "monthly_searches": [
            { "year": 2025, "month": 4, "search_volume": 27100 },
            { "year": 2025, "month": 3, "search_volume": 33100 }
          ]
        }
      ]
    }
  ]
}

A few notes on the response fields you get here. The search_volume field is a rounded average from Google Ads, which is why several keywords often share the same value. The granular, unrounded historical data lives in the monthly_searches array, where seasonal patterns are provided across the last 12 months. The competition and competition_index fields describe paid search competition, which are useful for understanding how competitive a keyword is in Google Ads and prioritizing PPC opportunities.

That covers one bulk request. But if you need to process tens or hundreds of thousands of keywords, two practical limits become important: how many keywords you can send per request, and how many requests you can make per minute.

Scaling bulk keyword research with Live vs Standard API requests

At larger volumes, there are two limits that matter in DataForSEO keyword research APIs. The first is the per-request ceiling of 1,000 keywords. The second is the rate limit.

Google Ads Live endpoints accept 12 requests per minute per account, so a single endpoint maxes out at around 720,000 keywords per hour. For most production workloads, that’s more than enough. If you want to update metrics for a very large keyword database or process millions of keywords at once, two options for scaling open up.

Option one: spread the work. The 12 RPM cap applies per account to Google Ads Live endpoints, but the global Keyword Data API ceiling is 2,000 API calls per minute across all endpoints combined. Splitting work between Google Ads, Bing Ads, and Bulk Clickstream Search Volume gives you more headroom than scaling any single endpoint. If your workflow also uses the DataForSEO Labs API, you can run up to 30 requests concurrently and process related enrichment tasks in parallel with Live Google Ads tasks rather than waiting for each request to finish one by one.

Option two: switch to the Standard mode. In short, Live is best when you need real-time results immediately in a user-facing interface, such as a dashboard or a keyword tool. Standard is better when the job can run in the background, such as updating keywords overnight, enriching a database, or collecting historical metrics, where processing the full dataset efficiently matters more than getting each individual response right away.

In the Standard mode, you POST a batch of tasks and retrieve the results later from a GET endpoint. Standard requests also cost less per call than Live, and you can pack up to 100 task objects into one POST, each with its own array of up to 1,000 keywords. The snippet below shows how to queue three different tasks to the Google Ads Search Volume endpoint in a single request:

curl --location --request POST \
  "https://api.dataforseo.com/v3/keywords_data/google_ads/search_volume/task_post" \
  --header "Authorization: Basic ${cred}" \
  --header "Content-Type: application/json" \
  --data-raw '[
    {
      "location_code": 2840,
      "language_code": "en",
      "keywords": ["buy laptop", "cheap laptops for sale"]
    },
    {
      "location_code": 2826,
      "language_code": "en",
      "keywords": ["buy laptop uk", "cheap laptops uk"]
    },
    {
      "location_code": 2124,
      "language_code": "en",
      "keywords": ["buy laptop canada", "cheap laptops canada"]
    }
  ]'

See the Google Ads Search Volume Task POST docs.

Each task object returns its own task ID, which you need to use to fetch the completed results from the matching Task GET endpoint.

You can either store the task IDs from the original POST response or use the Tasks Ready endpoint to check which tasks have been completed and collect their IDs before calling the appropriate Task GET endpoints.

For high-volume workflows, such as processing thousands of API requests per day or periodic collection of large datasets, callbacks, such as pingbacks and postbacks, are usually the better option. Use postbacks to have the completed task results sent to your server once the POST request is completed. If you prefer to receive only a notification that the task is complete, and fetch and process the results yourself, then use pingbacks.

Common mistakes when running bulk keyword research at scale

A few patterns trip up most teams the first time they push a bulk keyword research API workflow into production:

1. Mixing locations or languages in one task. Each task object applies a single location_code and language_code to every keyword in its keywords array. If you need US English and UK English data, create two task objects, not one keyword list with mixed data.
2. Exceeding the keyword limit per request. Each request supports a strict limit of keywords in a single task, usually 1000 keywords. If the array is too large, the endpoint may reject the request or return incomplete results. Split your lists client-side before sending, and validate the length beforehand.
3. Ignoring the 12 RPM cap on Google Ads Live endpoints. Sending requests in a tight loop can produce errors and burn budget on retries. Keep your Google Ads Live requests to roughly 10-12 per minute so you stay below the 12 RPM cap.
4. Using Live when Standard is a better fit. Live and Standard return the same data; Live just returns it synchronously at a higher per-call cost. For backfills, weekly refreshes, and overnight enrichment jobs, the Standard mode with task_post / task_get is usually the better choice.

If something doesn’t match the docs or an API behaves unexpectedly, you can always contact our support team. Drop a note in chat, and we will take a look and help you troubleshoot.

What to take away

Bulk keyword research at API scale lets you create workflows across a number of endpoints, each handling a specific part of the data enrichment, and each supporting up to 1,000 keywords per request. Pick the endpoint that matches the metrics you need, combine them when needed, and switch to the Standard mode when throughput matters more than an immediate response.

Try our keyword research APIs for free.