> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getunblocked.com/llms.txt
> Use this file to discover all available pages before exploring further.

# List Agent Access Logs

> List agent access logs for the authenticated team in ascending creation order.
Use `since` to start at an inclusive date-time or `after` to continue from a
previous page. Supplying both parameters returns HTTP 400.

Each page with agent access logs includes a `next` link, even if the page is
not full. Follow that link until the response is empty. Then stop and retry
the same URL when you poll again. Cursors use stable keyset pagination and
never expire.

**Authentication behavior:**
- **Personal Access Token (PAT) keys**: Team admins can export all agent access
  logs for their team; non-admin members receive 403 Forbidden.
- **Team-wide API keys**: All agent access logs for the team are returned.




## OpenAPI

````yaml https://getunblocked.com/api/v1/public-api.json get /agent-access-logs
openapi: 3.0.3
info:
  contact:
    email: help@getunblocked.com
    name: Unblocked
  description: >
    The Unblocked Public API offers seamless collection for managing custom data
    sources through a structured set of endpoints.

    It allows users to create collections and organize and upload documents.


    # Base URL

    The base URL for all requests is:


    ```jsx

    https://getunblocked.com/api/v1

    ```


    # Authentication

    Authentication requires an API key, obtainable from the web dashboard,

    which must be included in the `Authorization` request header for all
    endpoints.


    ```bash

    curl -X GET https://getunblocked.com/api/v1/collections \
         -H "Authorization: Bearer YOUR_API_KEY"
    ```


    # Rate Limits & Quotas


    **Resource Limits:**

    - Collections: Maximum 25 per team

    - Request Size: Maximum 10MB per request

    - Pagination: 1-200 items per page (default: 100)


    **Answers API:**

    - Daily Limit: 1000 questions per day per team

    - Quota Reset: Midnight PST

    - Exceeding the limit returns a 429 Too Many Requests error


    **Field Constraints:**

    - Collection name: 1-32 characters

    - Collection description: 1-4096 characters
  title: Unblocked Public API Reference
  version: v1
  x-logo:
    url: https://avatars.githubusercontent.com/u/91906527?s=300
    altText: Unblocked
servers:
  - url: https://getunblocked.com/api/v1
security:
  - ApiKeyBearerAuth: []
tags:
  - description: >
      Ask Unblocked questions and retrieve answers asynchronously. Submit a
      question using the PUT endpoint and poll for the response using the GET
      endpoint.
    name: Answers
  - description: >
      A collection in Unblocked allows you to organize related documents from
      various data sources, such as customer support tools, knowledge bases, and
      internal wikis, which are not natively supported by Unblocked.


      You can create multiple collections to manage documents from different
      sources.


      You have the ability to list, create, update, and delete them as needed.


      Deleting a collection will also remove all the associated documents.
    name: Collections
  - description: >
      Retrieve context from the data sources connected to Unblocked, including
      code, pull requests, issues, messages, and documentation.


      Research produces a synthesized answer with supporting sources. Search
      endpoints return relevant sources from a single content space. Query
      endpoints return the issues or pull requests matching a natural-language
      query with optional filters. The get endpoint retrieves URL content
      directly.


      **Authentication behavior:**

      - **Personal Access Token (PAT) keys**: Requests are attributed to the
      key's user

      - **Team-wide API keys**: Requests are attributed to the team
    name: Context
  - description: >
      A document contains content that Unblocked uses to answer questions. Each
      document is associated with a collection, so you must create a collection
      before adding documents. Documents used to provide answers will appear as
      references in the Unblocked interface.


      You can create and delete documents as needed.
    name: Documents
  - description: >
      SCIM (System for Cross-domain Identity Management) is a standard for
      automating the exchange of user identity information between identity
      domains or IT systems.


      You can use the SCIM API to manage users and groups in Unblocked.


      **Authentication behavior:**

      - **Public API and SCIM API keys**: Accepted for SCIM requests

      - **Personal Access Token (PAT) keys**: Only team admins may use the SCIM
      API; non-admin members receive `403 Forbidden`

      - **SAML prerequisite**: The team must have SAML identity provider
      metadata configured; otherwise requests receive `403 Forbidden`
    name: SCIM
  - description: >
      Retrieve a feed of team events for downstream ingestion into a security

      information and event management (SIEM) system. The feed currently
      includes

      audit logs. Poll the feed to collect new events.
    name: Security Events
  - description: |
      Retrieve usage data for Unblocked products and features.
    name: Usage
paths:
  /agent-access-logs:
    get:
      tags:
        - Security Events
      summary: List Agent Access Logs
      description: >
        List agent access logs for the authenticated team in ascending creation
        order.

        Use `since` to start at an inclusive date-time or `after` to continue
        from a

        previous page. Supplying both parameters returns HTTP 400.


        Each page with agent access logs includes a `next` link, even if the
        page is

        not full. Follow that link until the response is empty. Then stop and
        retry

        the same URL when you poll again. Cursors use stable keyset pagination
        and

        never expire.


        **Authentication behavior:**

        - **Personal Access Token (PAT) keys**: Team admins can export all agent
        access
          logs for their team; non-admin members receive 403 Forbidden.
        - **Team-wide API keys**: All agent access logs for the team are
        returned.
      operationId: listAgentAccessLogs
      parameters:
        - description: >
            Limit used to constrain results of list operations. When not
            specified a default limit of 100 is used.


            A maximum limit is applied to the results, so the server may respond
            with fewer results than requested; clients must not use this as a
            signal that this is the final page of results.
          in: query
          name: limit
          required: false
          schema:
            format: int32
            maximum: 200
            minimum: 1
            type: integer
        - description: >
            Opaque cursor for continuing after a previous page. Follow the URL
            marked `rel="next"`

            in the Link response header to obtain it; do not construct or parse
            the cursor.
          in: query
          name: after
          required: false
          schema:
            $ref: '#/components/schemas/Cursor'
        - description: >
            Include agent access logs created at or after this RFC 3339
            date-time. Use

            this to start an export; use `after` on subsequent pages. Cannot be
            combined

            with `after`.
          explode: true
          in: query
          name: since
          required: false
          schema:
            example: '2026-10-25T00:00:00Z'
            format: date-time
            type: string
          style: form
      responses:
        '200':
          content:
            application/json:
              schema:
                description: >-
                  Agent access logs in export order. An empty array means there
                  are no matching logs on this page.
                items:
                  $ref: '#/components/schemas/AgentAccessLog'
                type: array
          description: OK
          headers:
            link:
              $ref: '#/components/headers/Link'
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
          description: Error response
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
          description: Error response
        '403':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
          description: Error response
components:
  schemas:
    Cursor:
      description: >
        Opaque cursor to be used for paging in a forward or backward direction.
        Cursors are stateless and so they never expire.
      maxLength: 10000
      minLength: 1
      type: string
    AgentAccessLog:
      description: An agent access log.
      properties:
        eventId:
          description: Unblocked-generated unique identifier for this event.
          format: uuid
          type: string
        requestId:
          description: Client-supplied identifier of the MCP request.
          type: string
        timestamp:
          description: >-
            Time the tool was invoked, formatted as an RFC 3339 date-time with a
            UTC offset.
          example: '2026-10-25T16:03:21Z'
          format: date-time
          type: string
        durationMilliseconds:
          description: >-
            Elapsed wall-clock time from receiving the tool invocation to its
            terminal result, in milliseconds.
          example: 842
          format: int64
          minimum: 0
          type: integer
        toolName:
          description: Name of the tool that was invoked.
          example: context_research
          type: string
        method:
          description: MCP request method.
          example: tools/call
          type: string
        protocolVersion:
          description: Protocol version reported by the MCP client, when available.
          example: '2026-07-28'
          type: string
        client:
          allOf:
            - $ref: '#/components/schemas/AgentAccessLogClient'
          description: Client information reported for the MCP request.
        connectionType:
          description: Connection used to invoke the tool.
          enum:
            - remote
            - cli
          type: string
        actor:
          allOf:
            - $ref: '#/components/schemas/AuditLogActor'
          description: The person or API key that invoked the tool.
        result:
          description: Terminal result of the tool invocation.
          enum:
            - success
            - plan_upgrade_required
            - trial_expired
            - tool_error
            - protocol_error
            - timed_out
          type: string
        error:
          description: >-
            Error message for an unsuccessful tool invocation, when available.
            Does not contain request or response content.
          type: string
      required:
        - actor
        - client
        - connectionType
        - durationMilliseconds
        - eventId
        - method
        - requestId
        - result
        - timestamp
        - toolName
      type: object
    PublicApiError:
      properties:
        status:
          description: The HTTP status code
          example: 400
          type: integer
      required:
        - status
      type: object
    AgentAccessLogClient:
      description: Client information reported for the MCP request.
      properties:
        name:
          description: Client name reported in `io.modelcontextprotocol/clientInfo`.
          example: codex-mcp-client
          type: string
        version:
          description: Client version reported in `io.modelcontextprotocol/clientInfo`.
          example: 0.61.0
          type: string
        title:
          description: >-
            Client title reported in `io.modelcontextprotocol/clientInfo`, when
            available.
          example: Codex
          type: string
        userAgent:
          description: Raw HTTP User-Agent header sent with the request, when available.
          example: codex-mcp-client/0.61.0
          type: string
      type: object
    AuditLogActor:
      description: Actor details captured when the audit event was recorded.
      properties:
        type:
          description: >
            Kind of actor that initiated the action. `Person` is a user,
            `ApiKey` is an API

            credential, `DataSource` is an integration, and `System` is an
            Unblocked process.
          enum:
            - Person
            - System
            - ApiKey
            - DataSource
          type: string
        name:
          description: >-
            Display name of the actor as captured when the event was recorded;
            it can differ from the actor's current name.
          example: Jane Smith
          type: string
        email:
          description: >-
            Email address recorded for the actor, when available; system and
            integration actors may not have one.
          format: email
          type: string
        provider:
          description: >-
            Integration provider associated with the actor, using the `Provider`
            name, when applicable.
          example: GitHub
          type: string
      required:
        - name
        - type
      type: object
  headers:
    Link:
      description: |
        A link header providing navigation links related to the response.
      example: <https://api.example.com/some/resource>; rel="next"
      schema:
        type: string
  securitySchemes:
    ApiKeyBearerAuth:
      bearerFormat: Unblocked API Key
      description: The API key to authenticate requests. Obtainable from the web dashboard.
      scheme: bearer
      type: http

````