Batch & status

List events

Which of your writes have finished processing, and how many are still in flight.

GET /v1/events

SDK: korely.events(...). A write returns as soon as the memory is stored, with status processing, and the typed facts are extracted behind it. A read taken right away can find no facts yet. This endpoint tells "not finished" apart from "nothing to extract": each event is one write with its status, and processing counts every write still in flight, so a batch import can wait on one number.

No webhook fires when extraction finishes (the webhook events are memory.created, fact.invalidated and quota.warning), so poll this endpoint to know a write is ready.

Authentication

HTTP header, required: Authorization: Bearer kor_live_.... The key needs the memories:read scope and sees only the writes of its own project.

Query parameters

Parameter	Type	Required	Description
`user_id`	string	Optional	Only the writes of this end user, and `processing` counted for this end user only. Max 255 chars.
`status`	string	Optional	One of `processing`, `ready`, `error`. Applied before `limit`, so `?status=error` returns the most recent errors however many ready writes came after them.
`limit`	integer	Optional	How many events to return. Default `50`, between `1` and `200`.

Example request

curl "https://api.korely.ai/v1/events?user_id=customer-4812&limit=20" \
  -H "Authorization: Bearer kor_live_..."

from korely_memory import Korely

korely = Korely(api_key="kor_live_...", region="eu")

result = korely.events(user_id="customer-4812", limit=20)
print(result["processing"])             # 1
for e in result["events"]:
    print(e["memory_id"], e["status"])   # mem_c9a0b2 processing

import { Korely } from "korely-memory";

const korely = new Korely({ apiKey: "kor_live_..." });

const result = await korely.events({ user_id: "customer-4812", limit: 20 });
console.log(result.processing);          // 1
for (const e of result.events) {
  console.log(e.memory_id, e.status);    // mem_c9a0b2 processing
}

Response

200 OK. The newest writes first, and how many are still in flight.

{
  "events": [
    {
      "memory_id": "mem_c9a0b2",
      "user_id": "customer-4812",
      "agent_id": "support-bot",
      "status": "processing",
      "created_at": "2026-10-02T09:12:05+00:00"
    },
    {
      "memory_id": "mem_8f2c1a",
      "user_id": "customer-4812",
      "agent_id": "support-bot",
      "status": "ready",
      "created_at": "2026-10-02T09:10:41+00:00"
    }
  ],
  "processing": 1
}

Field	Type	Description
`events[].memory_id`	string	The memory the write stored (`mem_` prefix). Read it with Get a memory.
`events[].user_id`	string · null	The end user of the write.
`events[].agent_id`	string · null	The agent namespace of the write.
`events[].status`	string	`processing` while the facts are being extracted, then `ready`, or `error` when extraction failed.
`events[].created_at`	string · null	ISO 8601 time the memory was stored.
`processing`	integer	Writes of this key's project still in flight (of `user_id`, when given), counted over all of them. It ignores `status` and `limit`.

Errors

Status	Code	Cause
`401`	`invalid_key`	Missing or invalid `kor_live_` key.
`403`	`forbidden`	The key lacks the `memories:read` scope.
`422`	`invalid_request`	`status` is not one of the three values, `limit` is outside `1..200`, or `user_id` is longer than 255 chars.
`429`	`quota_exceeded`	Monthly query quota reached. Resets on the 1st of the month (UTC), or upgrade.
`429`	`rate_limit_exceeded`	Per-key rate limit exceeded. Honor the `Retry-After` header and back off.

Notes

No pagination. There is no offset: the endpoint answers "what happened lately", newest first. To walk every memory, use List memories.
Waiting on a batch. processing counts memories already stored, so it does not see a batch that has not stored its memories yet. Wait for Batch status to say completed (or failed) first, then poll this endpoint until processing is 0.
Counts as a read. Each call counts against your monthly query quota.

Add a memory, the write these events follow.
Memory history, the facts one memory produced, each with its time.
Webhooks, the events pushed to your server.