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

# List object extractors

> List all `ObjectExtractor` rows in the project, newest first.



## OpenAPI

````yaml /api-reference/openapi-full.yaml get /projects/{project_id}/object-extractors/
openapi: 3.0.3
info:
  title: Clarifeye Platform API — Full API Documentation
  description: >
    Complete REST API reference for the Clarifeye Platform.


    Documents every endpoint exposed by the platform — the public surface plus

    the advanced surface: pipeline customization (extraction flows, pipeline

    runs, warehouse tables, document tag/metadata configuration), the pre-MCP

    AI surface (agent settings, playground conversations, conversation-scoped

    feedback views, notifications), and the impersonation header. New AI

    integrations should consume knowledge via MCP rather than the

    conversation/agent-settings endpoints documented here.


    ## Authentication

    All endpoints require authentication. Include the Authorization header in
    every request using either format:

    - `Authorization: Token <token_key>`

    - `Authorization: Bearer <token_key>`


    ## Organization API Key Authentication

    The user-provisioning endpoints authenticate with an **org-scoped API key**
    instead of a user token:

    - `Authorization: Api-Key <key>`


    The key is minted internally by Clarifeye (not self-service) and is scoped
    to a single

    organization — it can only act on the organization whose UUID matches the
    `{id}` in the

    request path. The email domains a key may pre-create accounts for are
    configured by

    Clarifeye on the organization (`allowed_provisioning_domains`). Once you
    have a key and

    your domains are set, call `POST /organizations/{id}/provision-user/` to
    pre-create users

    and `POST /organizations/{id}/deprovision-user/` to remove them.


    ## Impersonation


    Certain endpoints support user impersonation for creating or listing data on
    behalf of other users.

    This is useful for integrating external systems that need to attribute
    actions to specific users.


    **Header:** `X-Impersonate-Email`


    **Required Permission:** `CAN_IMPERSONATE_OTHER_USERS` (contact Clarifeye to
    enable this permission)


    **Behavior:**

    - If the header is provided and the impersonator has the required
    permission, the action is performed as the target user

    - If the target user is not found, the request proceeds as the original
    authenticated user

    - If the target user does not have access to the project, the request
    proceeds as the original authenticated user

    - If the impersonator lacks the `CAN_IMPERSONATE_OTHER_USERS` permission,
    the header is ignored
  version: 1.0.0
  contact:
    name: Clarifeye Support
servers:
  - url: https://eu.app.clarifeye.ai/api/v1
    description: EU
  - url: https://us.app.clarifeye.ai/api/v1
    description: US
security:
  - BearerAuth: []
  - TokenAuth: []
tags:
  - name: Users
    description: Manage users within a project
  - name: Invitations
    description: Manage project invitations
  - name: Documents
    description: Manage documents within a project
  - name: Agent Settings
    description: Manage AI agent configurations
  - name: Conversations
    description: Create and interact with AI-powered conversations
  - name: Interviews
    description: Assign and review structured interview conversations
  - name: Feedback
    description: >-
      Submit and review feedback — standalone (content-only), agent-submitted
      (MCP), or linked to a conversation message
  - name: Tools
    description: Execute configured AI tools with custom parameters
  - name: Tables
    description: Perform CRUD operations on warehouse tables
  - name: Notifications
    description: Manage project-scoped notifications for users
  - name: Extraction Flows
    description: >-
      Manage extraction flows (auto-sync DAGs) — list, run, inspect statistics,
      update, and publish
  - name: Object Extractors
    description: |
      Extract structured data (instances of a Pydantic model) from chunks or
      blocks of documents. Update auto-creates a new `ObjectExtractorVersion`
      when version-bearing fields change.
  - name: Tag Extractors
    description: |
      Apply hierarchical metadata tags to chunks or documents using an LLM.
      Update auto-creates a new `TagExtractorVersion` when version-bearing
      fields change.
  - name: Chunks Extractors
    description: |
      Segment parsed documents into chunks for downstream processing.
      Update auto-creates a new `ChunksExtractorVersion` when version-bearing
      fields change.
  - name: Parsing Extractors
    description: |
      Convert source documents to text blocks via the parsing pipeline.
      Update auto-creates a new `ParsingExtractorVersion` when version-bearing
      fields change.
  - name: Document Filter Extractors
    description: |
      Restrict a downstream pipeline branch to documents matching a filter.
      Update auto-creates a new version when the filter changes.
  - name: Chunk Tag Filter Extractors
    description: |
      Restrict a downstream pipeline branch to chunks carrying specific tags.
      Update auto-creates a new version when the filter changes.
  - name: Document Tag Extractors
    description: |
      Apply a flat set of metadata tags to each document. Update auto-creates
      a new version when version-bearing fields change.
  - name: Tag Alerts Extractors
    description: |
      Run LLM-based alerts over already-extracted tag rows. Update auto-creates
      a new version when version-bearing fields change.
  - name: Object Alerts Extractors
    description: >
      Run LLM-based alerts over already-extracted object rows. Update
      auto-creates

      a new version when version-bearing fields change.
  - name: Imported Object Extractors
    description: |
      Hold objects imported from an external system (rather than extracted by
      an LLM). Useful for hydrating the warehouse with data produced outside
      the platform.
  - name: Pipeline Runs
    description: >-
      Inspect pipeline runs queued by extraction flows or other pipeline
      triggers — list runs and fetch the details/status of a single run
  - name: User Provisioning
    description: >
      Pre-create and de-provision org users via an org-scoped API key

      (`Authorization: Api-Key <key>`). The organization is resolved from the
      key.
  - name: Organization API Keys
    description: >
      Superuser management of org-scoped provisioning API keys. Minting and
      revoking

      are superuser-only; org admins can list/retrieve/reveal their own org's
      keys.
  - name: Design System Templates
    description: Reference/example files attached to a design template.
  - name: Artifacts
    description: |
      Knowledge-store artifact catalog — list artifacts, create/edit custom
      artifacts, manage scope membership, read and publish versions, configure
      the cohesion guide, and export/import the whole catalog. For type-aware
      reads and edits of artifact content, prefer the
      `read-write-*-artifact` tool endpoints.
paths:
  /projects/{project_id}/object-extractors/:
    get:
      tags:
        - Object Extractors
      summary: List object extractors
      description: List all `ObjectExtractor` rows in the project, newest first.
      operationId: listObjectExtractors
      parameters:
        - $ref: '#/components/parameters/ProjectId'
        - $ref: '#/components/parameters/Limit'
        - $ref: '#/components/parameters/Offset'
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/PaginatedResponse'
                  - type: object
                    properties:
                      results:
                        type: array
                        items:
                          $ref: '#/components/schemas/ObjectExtractor'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  parameters:
    ProjectId:
      name: project_id
      in: path
      required: true
      description: UUID of the project
      schema:
        type: string
        format: uuid
    Limit:
      name: limit
      in: query
      description: Maximum number of results per page
      schema:
        type: integer
        default: 100
        minimum: 1
        maximum: 1000
    Offset:
      name: offset
      in: query
      description: Number of results to skip for pagination
      schema:
        type: integer
        default: 0
        minimum: 0
  schemas:
    PaginatedResponse:
      type: object
      properties:
        count:
          type: integer
          description: Total number of results
        next:
          type: string
          format: uri
          nullable: true
          description: URL to next page of results
        previous:
          type: string
          format: uri
          nullable: true
          description: URL to previous page of results
        results:
          type: array
          items: {}
    ObjectExtractor:
      type: object
      description: |
        Extracts structured data (instances of a Pydantic model) from chunks
        or blocks of documents.
      properties:
        id:
          type: string
          format: uuid
          readOnly: true
        name:
          type: string
          description: Human-readable name.
          example: Contract clauses
        brief:
          type: string
          description: Short description shown in the UI.
          example: Extract obligations and effective dates from contracts.
        llm_model:
          type: string
          example: gpt-4o
        extractable_object:
          type: string
          nullable: true
          description: >-
            Display name of the object class (auto-derived from
            `extractable_pydantic_class` if omitted).
          example: ContractClause
        extractable_pydantic_class:
          type: string
          description: Python source of the Pydantic model used as the extraction schema.
          example: |
            from pydantic import BaseModel
            from typing import Optional

            class ContractClause(BaseModel):
                clause_type: str
                text: str
                effective_date: Optional[str] = None
        extraction_prompt:
          type: string
          example: >-
            Extract every distinct contractual obligation as a separate
            ContractClause object.
        document_ids:
          type: array
          items:
            type: string
            format: uuid
          description: >-
            Documents to extract from. Empty array means "all documents in the
            project".
          example:
            - b3c1d2e4-5f6a-4b7c-8d9e-0a1b2c3d4e5f
        document_ranges:
          type: object
          nullable: true
          description: >-
            Optional per-document page-range filter (`{document_id: [start_page,
            end_page]}`).
        compute_alerts:
          type: boolean
          default: false
          example: false
        add_anchoring_object:
          type: boolean
          default: false
          example: true
        filtered_on_block_types:
          type: boolean
          nullable: true
        block_types:
          type: array
          items:
            type: string
          nullable: true
          example:
            - text
            - table
        extract_single_object:
          type: boolean
          default: false
        block_grouping_config:
          type: object
          nullable: true
        pre_execution_filter:
          type: object
          nullable: true
          description: Filter applied to the source chunks/blocks before extraction runs.
        alerts_additional_instructions:
          type: string
          nullable: true
        alerts_llm_model:
          type: string
          nullable: true
        extraction_mode:
          type: string
          enum:
            - standard
            - agentic
          default: standard
        agentic_config:
          type: object
          nullable: true
          description: Configuration for `agentic` extraction mode.
        import_mode:
          type: boolean
          writeOnly: true
          default: false
          description: >-
            Bulk-import flag. When `true`, the create endpoint skips
            auto-version creation.
        created_at:
          type: string
          format: date-time
          readOnly: true
        updated_at:
          type: string
          format: date-time
          readOnly: true
        prompt_generation_status:
          type: string
          nullable: true
          readOnly: true
        deployed_extractable_pydantic_class:
          type: string
          nullable: true
          readOnly: true
        deployed_extraction_prompt:
          type: string
          nullable: true
          readOnly: true
        deployed_llm_model:
          type: string
          nullable: true
          readOnly: true
        extracted_objects_table:
          type: string
          format: uuid
          nullable: true
          readOnly: true
          description: ID of the warehouse `Table` where extracted objects are stored.
        alerts_table:
          type: string
          format: uuid
          nullable: true
          readOnly: true
        object_name:
          type: string
          readOnly: true
        blocks_table_version_info:
          type: object
          nullable: true
          readOnly: true
        chunks_table_version_info:
          type: object
          nullable: true
          readOnly: true
        table_version_updates:
          type: object
          nullable: true
          readOnly: true
        versions:
          type: array
          readOnly: true
          items:
            $ref: '#/components/schemas/ObjectExtractorVersion'
        default_version:
          allOf:
            - $ref: '#/components/schemas/ObjectExtractorVersion'
          nullable: true
          readOnly: true
        latest_version:
          allOf:
            - $ref: '#/components/schemas/ObjectExtractorVersion'
          nullable: true
          readOnly: true
    ObjectExtractorVersion:
      type: object
      description: >
        Immutable snapshot of an `ObjectExtractor`'s version-bearing
        configuration.

        New version rows are created automatically on PATCH when any of these

        fields differs from the latest version.
      properties:
        id:
          type: string
          format: uuid
          readOnly: true
        name:
          type: string
          readOnly: true
        created_at:
          type: string
          format: date-time
          readOnly: true
        updated_at:
          type: string
          format: date-time
          readOnly: true
        is_default:
          type: boolean
          readOnly: true
          description: Whether this version is the default version used by `run`.
        extractable_pydantic_class:
          type: string
          description: Python source of the Pydantic model used as the extraction schema.
          example: |
            from pydantic import BaseModel
            from typing import Optional

            class ContractClause(BaseModel):
                clause_type: str
                text: str
                effective_date: Optional[str] = None
        extraction_prompt:
          type: string
          example: >-
            Extract every distinct contractual obligation as a separate
            ContractClause object.
        llm_model:
          type: string
          example: gpt-4o
        add_anchoring_object:
          type: boolean
          example: true
        filtered_on_block_types:
          type: boolean
          nullable: true
        block_types:
          type: array
          items:
            type: string
          nullable: true
          example:
            - text
            - table
        extract_single_object:
          type: boolean
          example: false
        block_grouping_config:
          type: object
          nullable: true
          description: >-
            Optional configuration controlling how blocks are grouped before
            extraction.
        alerts_additional_instructions:
          type: string
          nullable: true
        extraction_mode:
          type: string
          enum:
            - standard
            - agentic
          default: standard
          nullable: true
        agentic_config:
          type: object
          nullable: true
          description: Configuration for `agentic` extraction mode.
    Error:
      type: object
      properties:
        error:
          type: string
          description: Error message
      example:
        error: User not found
  responses:
    Unauthorized:
      description: Unauthorized - missing or invalid authentication
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Authentication credentials were not provided.
    Forbidden:
      description: Forbidden - insufficient permissions
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: You do not have permission to perform this action.
    NotFound:
      description: Not found - resource does not exist
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Not found.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: 'Use Authorization: Bearer <token>'
    TokenAuth:
      type: apiKey
      in: header
      name: Authorization
      description: 'Use Authorization: Token <token>'

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.