logs

List the indexing logs

Every indexing Lookio ran, one line each: a file read, a web page or a site's page fetched, a text added, and each update of them. Latest first, with its status (indexed, failed with the reason, processing…), what reading found (pages, words, passages, warnings) and how long it took. A site's sync re-reads its changed pages: those found unchanged are left out unless include_unchanged=true. Filter by resource_id, status, source_type, q and from/to, and paginate with cursor. Costs nothing.

GET/v1/logs/indexing

Request

curl --request GET \
  --url 'https://api.lookio.app/v1/logs/indexing' \
  --header 'Authorization: <api-key>'

import json
import requests

url = "https://api.lookio.app/v1/logs/indexing"
headers = {
  "Authorization": "<api-key>"
}

response = requests.request("GET", url, headers=headers)
print(response.json())

const response = await fetch("https://api.lookio.app/v1/logs/indexing", {
  method: "GET",
  headers: {
    "Authorization": "<api-key>"
  },
});

const data = await response.json();
console.log(data);

<?php
$client = curl_init();

curl_setopt($client, CURLOPT_URL, "https://api.lookio.app/v1/logs/indexing");
curl_setopt($client, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($client, CURLOPT_HTTPHEADER, [
    "Authorization: <api-key>",
]);
curl_setopt($client, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($client);
curl_close($client);
echo $response;

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  req, _ := http.NewRequest("GET", "https://api.lookio.app/v1/logs/indexing", nil)
  req.Header.Set("Authorization", "<api-key>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  data, _ := io.ReadAll(res.Body)
  fmt.Println(string(data))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var request = HttpRequest.newBuilder(URI.create("https://api.lookio.app/v1/logs/indexing"))
    .header("Authorization", "<api-key>")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();

var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

require 'net/http'
require 'json'

uri = URI("https://api.lookio.app/v1/logs/indexing")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "<api-key>"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts response.body

application/json

{
  "data": [
    {
      "id": "<string>",
      "status": "queued",
      "resource": {
        "id": "<string>",
        "title": "<string>",
        "source_type": "<string>"
      },
      "name": "<string>",
      "page_url": null,
      "file": {
        "name": null,
        "media_type": null,
        "byte_size": 123
      },
      "reader": null,
      "page_count": 123,
      "word_count": 123,
      "chunk_count": 123,
      "warnings": [
        "<string>"
      ],
      "error": null,
      "started_at": "<string>",
      "finished_at": null,
      "duration_ms": 123
    }
  ],
  "has_more": true,
  "next_cursor": null,
  "limit": 123,
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>",
    "action_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>",
    "action_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>",
    "action_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>",
    "action_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>",
    "action_url": "<string>"
  },
  "request_id": "<string>"
}

Requires resources:read.

One line per indexing: a file read, a web page or a site’s page fetched, a text added, and each update of them. Results come latest first, and you page with cursor, an opaque string: pass next_cursor back unchanged. See Pagination.

A line carries the status, the resource it belongs to, what reading found (page_count, word_count, chunk_count, warnings), how long it took, and the error of a failed one. Statuses are queued, processing, indexed (searchable now), replaced (indexed, then replaced by a newer indexing), unchanged (re-read, same text), skipped (a newer indexing finished first) and failed.

By default the list leaves out unchanged and skipped, so a site’s weekly sync shows only what changed. Add include_unchanged=true to see every page it re-read. Narrow the list with resource_id (for a site, all its pages), status (comma-separated), source_type (file, url, site or text), q (words in the title, the file name or the page address) and from and to. status=failed is the quickest way to find what to retry.

See Logs. The figures over the same filters are in Retrieve the figures of the indexing logs.

Authorizations

Authorizationbearerin headerrequired

Query parameters

resource_idstringpattern: ^res_[abcdefghjkmnpqrstuvwxyz23456789]{12}$

Only this resource's indexings (a site: all its pages).

statusstringlength: ≥ 1 chars

Only these statuses, comma-separated: queued, processing, indexed (searchable now), replaced (indexed, then replaced by a newer indexing), unchanged (re-read, same text), skipped (a newer indexing finished first), failed. Default: all but unchanged and skipped.

source_typeenum<string>one of: file, url, site, text

Only resources of this kind.

qstringlength: 1–200 chars

Words in the resource's title, the file's name, or the page's address or title.

include_unchangedboolean | enum<string>

Also list the pages a sync re-read and found unchanged. Default false.

fromstring

Only indexings started since this ISO 8601 date or timestamp.

tostring

Only indexings started until this ISO 8601 date or timestamp.

cursorstringlength: 1–200 chars

Pass next_cursor from the previous page, unchanged.

limitintegerrange: 1–100

Number of items to return. Values outside 1-100 are clamped, and the response reports the limit actually applied.

Response

application/json

List the indexing logs

dataobject[]required

Show child attributes

data.idstringrequired

The indexing's id (a version of the document).

data.statusenum<string>requiredone of: queued, processing, indexed, replaced, unchanged, skipped, failed

data.resourceobjectrequired

Show child attributes

data.resource.idstringrequired

data.resource.titlestringrequired

data.resource.source_typestringrequired

data.namestringrequired

What was read: a site page's title or address, a file's name, or the resource's title.

data.page_urlstringnullrequired

A site page's address.

data.fileobject | nullrequired

Show child attributes

data.file.namestringnullrequired

data.file.media_typestringnullrequired

data.file.byte_sizeinteger | nullrequired

data.readerstringnullrequired

How the content was read (the parser or OCR used).

data.page_countinteger | nullrequired

data.word_countinteger | nullrequired

data.chunk_countintegerrequired

Passages indexed.

data.warningsstring[]required

What reading noticed, such as pages without text.

data.errorstringnullrequired

Why it failed, for failed.

data.started_atstringrequired

data.finished_atstringnullrequired

data.duration_msinteger | nullrequired

has_morebooleanrequired

True when another page follows: pass next_cursor back as cursor.

next_cursorstringnullrequired

Pass it back unchanged as cursor. Null on the last page.

limitintegerrequired

The page size actually applied.

request_idstringrequired

List the indexing logs

Authorizations

Query parameters

Response

Use these docs with your AI tools

Query these docs via MCP

Query these docs over HTTP

Read these docs as Markdown