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

# Create entities in batch

> Creates multiple entities in a single request. Each entity is processed independently — a failure in one does not affect others.

Each entity requires a `name` plus at least one of: a `description` or a `domain`. See [Create entity](https://www.newscatcherapi.com/docs/web-search-api/api-reference/entities/create-entity) for the full field reference.

Returns an array of `{id, status}` objects in the same order as the input array.




## OpenAPI

````yaml catch-all-api post /catchAll/entities/batch
openapi: 3.1.0
info:
  title: NewsCatcher CatchAll API
  version: 1.6.4
  description: >
    CatchAll is a web search API that generates unique datasets that don't exist
    anywhere else on the web. Built on NewsCatcher's proprietary real-world
    event index, it delivers state-of-the-art recall—finding all relevant
    events, not just top results.


    ### Authentication


    All endpoints except /health and /version require `x-api-key` header. If the
    key is invalid or missing, the API returns the `403 Forbidden` error.


    ### Job workflow


    1. (Optional) Get suggestions via /catchAll/initialize

    2. Submit a query via /catchAll/submit with optional date ranges and custom
    validators/enrichments

    3. Poll /catchAll/status/{job_id} until completed (10-15 minutes)

    4. Retrieve results via /catchAll/pull/{job_id}


    ### Monitor workflow


    1. Create successful job via /catchAll/submit

    2. Create monitor via /catchAll/monitors/create with schedule

    3. Retrieve aggregated results via /catchAll/monitors/pull/{monitor_id}


    ### Webhook workflow


    1. Create a webhook via `POST /catchAll/webhooks`

    2. Attach it to a job or monitor via `POST
    /catchAll/webhooks/{webhook_id}/resources`,
       or pass `webhook_ids` at job or monitor creation time
    3. Receive HTTP notifications at the configured URL when each job completes


    ### Company search workflow


    1. Create a dataset via `POST /catchAll/datasets/` or `POST
    /catchAll/datasets/upload`

    2. Wait for the dataset `latest_status` to reach `ready`

    3. Submit a job with `connected_dataset_ids` pointing to your dataset

    4. Retrieve results — each record includes a `connected_entities` array
       with relevance scores per matched company

    ### Important notes


    **Dynamic schemas**: Response schemas are generated dynamically by LLMs.
    Field names in the `enrichment` object may vary and are not deterministic
    across jobs unless explicitly specified.
  contact:
    name: NewsCatcher
    url: https://newscatcherapi.com
    email: support@newscatcherapi.com
servers:
  - url: https://catchall.newscatcherapi.com
    description: Production server
security:
  - ApiKeyAuth: []
tags:
  - name: Jobs
    description: Operations to create, monitor, and retrieve job results.
    externalDocs:
      description: Learn about job lifecycle and status tracking
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/get-started/quickstart
  - name: Monitors
    description: Operations to create, operate and retrieve monitor results.
    externalDocs:
      description: >-
        Automate recurring queries with scheduled jobs and webhook
        notifications.
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/guides-and-concepts/monitors
  - name: Webhooks
    description: >
      Operations to create and manage reusable webhook endpoints.


      A webhook is a named HTTP endpoint that receives a POST notification

      when a job or monitor completes. Create webhooks once at the organization

      level and attach them to any number of jobs or monitors via `webhook_ids`.

      Supports Slack, Microsoft Teams, and generic HTTP targets with
      configurable

      delivery modes, authentication, and headers.
    externalDocs:
      description: Learn about centralized webhooks and notification setup
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/guides-and-concepts/webhooks
  - name: Entities
    description: >
      Operations to create, update, and delete company entities.


      Entities are the building blocks of Company Watchlist. Each entity
      represents

      a company (or person) you want to track. Add identifying information such
      as

      domain, alternative names, and key persons to improve matching quality.
    externalDocs:
      description: Learn about Company Watchlist and entities
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/guides-and-concepts/company-search
  - name: Datasets
    description: >
      Operations to create and manage datasets of entities.


      A dataset is a named collection of entities — think of it as a watchlist
      or

      portfolio. Connect a dataset to a job via `connected_dataset_ids` to
      activate

      Company Watchlist. Datasets can be reused across multiple jobs and
      monitors.
    externalDocs:
      description: Learn about datasets and Company Watchlist
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/guides-and-concepts/company-search
  - name: Projects
    description: |
      Operations to create, organize, and manage projects.

      A project is a named container for jobs, monitors, and datasets. Group
      related resources by use case, team, or client, and share them with
      teammates. Resources can be assigned at creation time or post-hoc.
    externalDocs:
      description: Learn about projects and resource organization
      url: >-
        https://www.newscatcherapi.com/docs/web-search-api/guides-and-concepts/projects
  - name: Meta
    description: Operations to check API health and version.
externalDocs:
  description: Find out more about NewsCatcher CatchAll API
  url: https://www.newscatcherapi.com/docs/web-search-api/get-started/introduction
paths:
  /catchAll/entities/batch:
    post:
      tags:
        - Entities
      summary: Create entities in batch
      description: >
        Creates multiple entities in a single request. Each entity is processed
        independently — a failure in one does not affect others.


        Each entity requires a `name` plus at least one of: a `description` or a
        `domain`. See [Create
        entity](https://www.newscatcherapi.com/docs/web-search-api/api-reference/entities/create-entity)
        for the full field reference.


        Returns an array of `{id, status}` objects in the same order as the
        input array.
      operationId: createEntitiesBatch
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateEntitiesBatchRequest'
            example:
              entities:
                - name: OpenAI
                  entity_type: company
                  description: Artificial intelligence research company
                  additional_attributes:
                    company_attributes:
                      domain: openai.com
                      alternative_names:
                        - Open AI
                      key_persons:
                        - Sam Altman
                - name: Stripe
                  entity_type: company
                  description: Online payment processing platform
                  additional_attributes:
                    company_attributes:
                      domain: stripe.com
                      key_persons:
                        - Patrick Collison
                        - John Collison
      responses:
        '200':
          $ref: '#/components/responses/CreateEntitiesBatchResponse'
        '400':
          $ref: '#/components/responses/EntityBadRequestError'
        '403':
          $ref: '#/components/responses/ForbiddenError'
components:
  schemas:
    CreateEntitiesBatchRequest:
      type: object
      required:
        - entities
      properties:
        entities:
          type: array
          items:
            $ref: '#/components/schemas/CreateEntityRequest'
          description: |
            Array of entities to create. Each item follows the same schema
            as single entity creation.
          minItems: 1
    CreateEntityRequest:
      type: object
      required:
        - name
      description: >
        Request body for creating a single entity. The `name` field is required.

        You must also provide at least one of: a top-level `description` or a
        `domain`

        inside `additional_attributes.company_attributes`.

        The more fields you provide, the better the matching quality.
      properties:
        name:
          type: string
          minLength: 1
          description: The company or person name. Required and must be non-empty.
          example: NewsCatcher
        entity_type:
          $ref: '#/components/schemas/EntityType'
        description:
          type: string
          description: >
            Free-text description of the entity used for disambiguation when
            similar names exist. See [Writing effective
            descriptions](https://www.newscatcherapi.com/docs/web-search-api/concepts/company-search#writing-effective-descriptions)
            for guidance on improving matching quality.
          example: >-
            NewsCatcher is a data-as-a-service company providing news
            intelligence APIs including the CatchAll Web Search API (2B+ web
            pages indexed) and News API (140,000+ sources, 100+ countries).
        external_entity_id:
          type: string
          maxLength: 255
          description: >
            Optional external identifier for this entity. Free-form string, not
            enforced as unique. Use it to store your own CRM, data warehouse, or
            internal database ID so you can join CatchAll results back to your
            systems.
          example: crm-12345
        additional_attributes:
          $ref: '#/components/schemas/AdditionalAttributes'
    CreateEntitiesBatchResponse:
      type: object
      required:
        - entities
        - count
      properties:
        entities:
          type: array
          items:
            $ref: '#/components/schemas/CreateEntityResponse'
          description: |
            Array of created entity stubs in the same order as the input.
        count:
          type: integer
          description: Total number of entities created.
          example: 3
    EntityValidationErrorBody:
      type: object
      required:
        - message
        - status
        - status_code
      description: |
        Error body returned by entity endpoints for field-level validation
        failures. Uses a different structure from the standard `Error` schema
        (`{"detail": "..."}`) used elsewhere in the API.
      properties:
        message:
          type: string
          description: |
            Human-readable description of all validation errors, including
            field path, failure message, and error type.
          example: >-
            Validation Error with the following fields: [{'field':
            'body.entity_type', 'message': "entity_type must be one of
            ('company', 'person')", 'type': 'value_error'}]
        status:
          type: string
          description: HTTP status text.
          example: Bad Request
        status_code:
          type: integer
          description: HTTP status code.
          example: 400
    Error:
      type: object
      properties:
        detail:
          type: string
          description: Error message.
          example: Invalid API key
    EntityType:
      type: string
      enum:
        - company
        - person
      description: |
        The type of entity.

        - `company`: A company or organization (default).
        - `person`: An individual person.
      default: company
    AdditionalAttributes:
      type: object
      description: Additional attributes for the entity, keyed by entity type.
      properties:
        company_attributes:
          $ref: '#/components/schemas/CompanyAttributes'
    CreateEntityResponse:
      type: object
      required:
        - id
        - status
      properties:
        id:
          type: string
          format: uuid
          description: Unique identifier of the created entity.
          example: 854198fa-f702-49db-a381-0427fa87f173
        status:
          type: string
          description: >
            Initial status of the entity. Always `pending` immediately after
            creation — enrichment happens asynchronously.
          example: pending
    CompanyAttributes:
      type: object
      description: >
        Identifying attributes for a company entity. All fields are optional but
        improve matching quality.
      properties:
        domain:
          type:
            - string
            - 'null'
          description: |
            Company website domain without protocol or trailing slash.

            The most reliable identifier — strongly recommended when available.
          example: newscatcherapi.com
        key_persons:
          type:
            - array
            - 'null'
          items:
            type: string
          description: >
            Names of key people associated with the company (founders,
            executives, etc.). Improves matching for articles that mention
            people rather than the company name.
          example:
            - Artem Bugara
            - Maksym Sugonyaka
        alternative_names:
          type:
            - array
            - 'null'
          items:
            type: string
          description: >
            Alternative names, abbreviations, or aliases. Helps resolve common
            variations of the company name.
          example:
            - NewsCatcher CatchAll
            - NewsCatcher API
  responses:
    CreateEntitiesBatchResponse:
      description: Batch of entities created successfully.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/CreateEntitiesBatchResponse'
          example:
            entities:
              - id: 88430468-d784-485d-84d5-6964a29ccd1e
                status: pending
              - id: ad4908fe-6db5-4237-a137-68dd8fc9fedc
                status: pending
            count: 2
    EntityBadRequestError:
      description: |
        Validation error in entity field values.

        Returned when required fields are missing or field values are invalid
        (for example, an unrecognised `entity_type` value). The response body
        uses a `message`/`status`/`status_code` structure, distinct from the
        standard `detail`-based error format used elsewhere in the API.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/EntityValidationErrorBody'
          examples:
            missing_name:
              summary: Required field missing
              value:
                message: >-
                  Validation Error with the following fields: [{'field':
                  'body.name', 'message': 'field required', 'type':
                  'value_error.missing'}]
                status: Bad Request
                status_code: 400
            invalid_entity_type:
              summary: Invalid enum value
              value:
                message: >-
                  Validation Error with the following fields: [{'field':
                  'body.entity_type', 'message': "entity_type must be one of
                  ('company', 'person')", 'type': 'value_error'}]
                status: Bad Request
                status_code: 400
    ForbiddenError:
      description: Invalid or missing API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: API key for authentication.

````