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

# Validate Competitor Joiners

> Monitor or ignore the joiners a team refresh found, in bulk

> [!NOTE]
>
> Kept for compatibility. There is no review queue any more: the monthly team refresh follows the
> people it finds automatically while you have free slots, and past your limit adds them Paused. So
> this call normally finds nobody waiting.

It decides for people still waiting with `status: "pending"`: they take no slot and their activity
is not collected.

* `monitor` makes them monitored. Each takes a slot. It is all or nothing: when they do not all fit
  in your free slots, nobody changes and the answer is `409 NO_SLOT`.
* `ignore` removes them for good. No team search adds them back.

Without `person_ids`, the action applies to every pending person of the competitor. For
one person, [Update Competitor Team Member](https://docs.clustr-ai.com/api-reference/update-competitor-team-member.md) does the
same.

```bash cURL theme={null}
curl -X POST https://api.clustr-ai.com/api/public/competitors/cmp_r0jpyyqyeh0txpgdhb604j2g9s/tracked-persons/validate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "action": "monitor" }'
```

```python Python theme={null}
import requests

requests.post(
    "https://api.clustr-ai.com/api/public/competitors/cmp_r0jpyyqyeh0txpgdhb604j2g9s/tracked-persons/validate",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"action": "monitor"},
)
```

```javascript JavaScript theme={null}
await fetch("https://api.clustr-ai.com/api/public/competitors/cmp_r0jpyyqyeh0txpgdhb604j2g9s/tracked-persons/validate", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ action: "monitor" }),
});
```

```json 200 theme={null}
{
  "success": true,
  "data": {
    "monitored": 3,
    "ignored": 0,
    "slot_usage": { "used": 185, "total": 200, "paused": 3, "pending": 0, "plan": "l200", "active": 185, "limit": 200 }
  }
}
```

```json 409 theme={null}
{
  "success": false,
  "error": { "message": "No slot left: 3 needed, 1 free. Pause someone else, or contact Clustr to raise the limit.", "code": "NO_SLOT" }
}
```


## OpenAPI

````yaml POST /competitors/{id}/tracked-persons/validate
openapi: 3.1.0
info:
  title: Clustr Public API
  description: >
    Programmatic access to your Clustr network: import connectors, search warm
    intros (opportunities), and manage target accounts.


    ## Authentication

    All endpoints require a Bearer token (API key) in the `Authorization`
    header.


    ```

    Authorization: Bearer <your_api_key>

    ```


    API keys can be created and managed from the [API settings
    page](https://app.clustr-ai.com/api).
  version: '1.0'
  contact:
    name: Clustr Support
    url: https://clustr-ai.com
servers:
  - url: https://api.clustr-ai.com/api/public
    description: Production
security:
  - BearerAuth: []
paths:
  /competitors/{id}/tracked-persons/validate:
    post:
      tags:
        - Competitor Monitoring
      summary: Validate Competitor Joiners
      description: >-
        Monitors or ignores, in bulk, the joiners a team refresh found (people
        with status `pending`). `monitor` succeeds only when every person fits
        in your free slots; otherwise it answers `409` with code `NO_SLOT` and
        nobody changes status. `ignore` removes the people permanently. When you
        leave out `person_ids`, the action applies to every pending person.
      operationId: validateCompetitorJoiners
      parameters:
        - name: id
          in: path
          required: true
          description: >-
            The competitor's Clustr ID (`cmp_…`), from [List
            Competitors](/api-reference/list-competitors).

            The id from earlier responses also works.
          schema:
            type: string
          example: cmp_fq6z15b3h85mb7j7b0w8f9khsa
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - action
              properties:
                action:
                  type: string
                  description: 'The action to apply: `monitor` or `ignore`.'
                  enum:
                    - monitor
                    - ignore
                person_ids:
                  type: array
                  description: >-
                    The Clustr IDs (`ctp_…`) of the people to act on, as [List
                    Competitor

                    Team](/api-reference/list-competitor-team) returns them with
                    `status=pending`. Leave it out to

                    act on every pending person. The ids from earlier responses
                    also work.
                  items:
                    type: string
      responses:
        '200':
          description: The number of people whose status changed.
          content:
            application/json:
              schema:
                type: object
                required:
                  - success
                  - data
                properties:
                  success:
                    type: boolean
                    example: true
                  data:
                    type: object
                    properties:
                      monitored:
                        type: integer
                        example: 3
                      ignored:
                        type: integer
                        example: 0
                      slot_usage:
                        $ref: '#/components/schemas/SlotUsage'
        '401':
          description: Invalid or missing API key
        '404':
          description: Competitor not found
        '409':
          description: Not enough free slots (`NO_SLOT`)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    SlotUsage:
      type: object
      description: >-
        Your competitor monitoring slots. Each monitored person takes one slot,
        whatever the competitor. The limit comes from your workspace's plan,
        which Clustr sets.
      properties:
        used:
          type: integer
          description: How many people are monitored.
          example: 182
        total:
          type: integer
          description: The slot limit.
          example: 200
        paused:
          type: integer
          description: How many people are paused, for lack of a slot or manually.
          example: 12
        pending:
          type: integer
          description: How many joiners are waiting for you to validate them.
          example: 3
        plan:
          type: string
          enum:
            - s50
            - m100
            - l200
            - custom
          example: l200
        active:
          type: integer
          description: The same count as `used`.
          example: 182
        limit:
          type: integer
          description: The same limit as `total`.
          example: 200
    ErrorResponse:
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          example: false
        error:
          type: object
          properties:
            message:
              type: string
              example: Invalid request body
            code:
              type: string
              example: BAD_REQUEST
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: The API key you created on the API settings page of the Clustr app.

````

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