How to Retrieve and Export Your DataForSEO Tasks with the ID List Endpoint

If you’ve ever lost track of which tasks you submitted to DataForSEO, or needed to re-download results you didn’t store on your side, the ID List endpoint is your built-in lookup tool. It lets you pull a complete record of the tasks you created during any time window, along with each task’s identifier, timestamps, status, and cost. Using this endpoint, you can audit what you ran or go back and retrieve API results you no longer have in storage.

At a glance, each entry in the list provided in the ID List endpoint gives you:

• the task’s unique identifier (the same ID you’d use to fetch its results);
• the specific endpoint the task was sent to;
• when the task was submitted and when it was finished;
• the completion status, and how much each specific task cost you.

The ID List endpoint works across all task-based APIs, including SERP, Keywords Data, Backlinks, Content Analysis, On Page, DataForSEO Labs, Business Data, App Data, Merchant, Domain Analytics, and AI Optimization. You choose which API to query by changing one segment of the request URL. For example, a call aimed at the SERP API returns only your SERP tasks:

POST https://api.dataforseo.com/v3/serp/id_list

The ID List endpoint is free. It does not deduct from your balance and does not charge per call, so you can run it as often as you need (within the rate limit of 10 API calls per minute) without affecting your usage costs.

How to export DataForSEO API tasks?

Before getting into the parameters, it helps to understand the overall pattern. Exporting your tasks is always a two-step process: first you look up the tasks, then you pull their results.

Step 1: Look up your tasks (ID List).
You call the ID List endpoint with a date range and the API you’re interested in. In return you receive a list of every task you created in that window, each with its unique identifier, the endpoint it was sent to, its timestamps, status, and cost. If you need a reminder of what each task was asking for, you can also request the original submission parameters alongside each ID.

Step 2: Pull the results (Task GET).
The ID List gives you the directory — not the content. To actually export a task’s full results, you take its identifier from the list and pass it to the standard Task GET endpoint for that same API. For example, an ID that came back from a SERP ID List call is fetched through the SERP Task GET endpoint; an ID from a Backlinks ID List call is fetched through the Backlinks Task GET endpoint. You should repeat this for each task you want to recover to obtain the results you need.

Both steps are independent, so you can split the work: pull the full ID list once, store it on your side, and then fetch results in batches at your own pace. Note that metadata is only available for tasks that were made within one month.

Building your request

Now, let’s look at how to actually construct an ID List call. There are only two things to get right: which API you’re querying, and the date window you want to cover. Everything else is optional tuning.

The POST request URL
Every ID List call goes to the same base address, with one segment you swap out to choose the API:

POST https://api.dataforseo.com/v3/{api}/id_list

Replace {api} with the namespace you want to query. A call aimed at serp returns only your SERP API tasks; one aimed at backlinks returns only your Backlinks API tasks. If you work across several APIs, you’ll make one ID List call per each API.

Request parameters

You send the parameters as a JSON array in the body of the POST request. You can check the full list of available parameters in the documentation. The only required fields are datetime_from and datetime_to. If you omit the rest, the API applies sensible defaults: up to 1000 IDs, starting from the oldest in your window, in ascending order, without task metadata.

Suppose you want to review all the SERP tasks you submitted during the first week of August 2026. You’d set the parameters like this:

• api in the address: serp
• datetime_from: 2025-08-01 00:00:00 +00:00
• datetime_to: 2025-08-07 23:59:59 +00:00
• limit: 1000 (or omit it — same result)
• sort: desc (so the most recent tasks appear first)
• include_metadata: true (because you want to see the keyword and location for each task, not just the IDs)

That call returns up to 1000 SERP tasks you created during that week, newest first, each with its original request parameters attached. If the week was busier than 1000 tasks, you’d page through the rest using the offset parameter.

Note that the datetime_from / datetime_to range selects tasks based on the moment you created them. A task submitted at 23:59 on August 7th will appear in an “August 1–7” window even if it didn’t finish processing until a few seconds into August 8th. The completion time is still returned in the response, it just isn’t what the window filters on.

Request example (PHP)

 "2025-08-01 00:00:00 +00:00",
   "datetime_to" => "2025-08-07 23:59:59 +00:00",
   "limit" => 100,
   "offset" => 0,
   "sort" => "desc"
   "include_metadata" => true
);
try {
   // You can use the path to any API in the POST request instead of 'serp'
   // POST /v3/serp/id_list
   // the full list of possible parameters is available in documentation
   $result = $client->post('/v3/serp/id_list', $post_array);
   print_r($result);
   // do something with post result
} catch (RestClientException $e) {
   echo "n";
   print "HTTP code: {$e->getHttpCode()}n";
   print "Error code: {$e->getCode()}n";
   print "Message: {$e->getMessage()}n";
   print  $e->getTraceAsString();
   echo "n";
}
$client = null;
?>

Response example (JSON, annotated)

{
  "version": "0.1.20250816",
  "status_code": 20000,           // 20000 = success
  "status_message": "Ok.",
  "time": "1.6078 sec.",          // how long this lookup took
  "cost": 0,                      // always 0 — this endpoint is free
  "tasks_count": 1,               // number of lookup tasks in this response
  "tasks_error": 0,               // how many of those errored
  "tasks": [
    {
      "id": "02061637-4426-0521-0000-00f930977c58",
      "status_code": 20000,
      "status_message": "Ok.",
      "time": "1.5527 sec.",
      "cost": 0,
      "result_count": 3,          // how many task IDs matched your window
      "path": ["v3", "serp", "id_list"],
      "data": {                   // echoes back the parameters you sent
        "api": "serp",
        "function": "id_list",
        "datetime_from": "2025-07-01 00:00:00 +00:00",
        "datetime_to": "2025-08-01 00:00:00 +00:00",
        "limit": 1000,
        "sort": "desc",
        "include_metadata": true
      },
      "result": [
        {
          "id": "01161555-4426-0139-0000-027b8dd062f3",   // ← the task ID you'll use in Task GET
          "url": "v3/serp/google/organic/live/advanced",   // which endpoint this task originally hit
          "datetime_posted": "2025-07-16 13:55:36 +00:00", // when you submitted it
          "datetime_done": "2025-07-16 13:55:36 +00:00",   // when it finished
          "status": "20000",                               // numeric status; 20000 = completed successfully
          "cost": 0.002,                                   // what the original task cost
          "metadata": {                                    // only present when include_metadata = true
            "keyword": "water quality",
            "location_name": "United States",
            "language_name": "English",
            "device": "desktop",
            "os": "windows"
          }
        },
        // ... more task entries ...
      ]
    }
  ]
}

Wrapping up

The ID List endpoint is a simple but powerful tool for keeping track of your DataForSEO activity. In essence:

• It’s your task directory. For any date window within the last six months, you can pull a complete list of tasks you created across any of the task-based APIs – with their IDs, timestamps, status, and cost.
• It’s free and lightweight. No balance deduction, no per-call charge. Use it freely to audit what you ran, reconcile billing, or recover task IDs you didn’t store.
• Metadata is available for the recent month. Turn on include_metadata when you need to recall the original request parameters for each task. Just keep the window within the last 30 days, since the metadata storage has shorter retention.
• The export is two steps. ID List gives you the IDs; the standard Task GET endpoints give you the results. Retrieve only what you need.
• Mind the rate limit. Ten calls per minute, up to 1000 IDs each. For large exports, split by date window rather than relying on large offsets.
• If you have tasks that returned an error and you want to investigate them, pair this endpoint with the API Errors endpoint, which covers the past 7 days and is specifically designed for error reporting.

For the full parameter reference and live response examples, refer to the ID List documentation.