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

# Public API Integration

> Feature coverage and implementation details for Public API integration

## Implementation Overview

**Implementation Type:** Minimal Implementation (Webhook-based)\
**Note Format:** N/A\
**Status:** Production Ready

The Public API integration is not a traditional ATS integration. Instead, it provides a minimal ATS client implementation that supports webhook-based integrations for organizations using Tenzo's Public API rather than a traditional ATS system.

## Configuration

| Property               | Value         | Description                |
| ---------------------- | ------------- | -------------------------- |
| Provider Enum          | `public_api`  | Identifier in ProviderEnum |
| Note Format            | N/A           | Not applicable             |
| Disposition Reasons    | Not Supported | Not applicable             |
| All Application Stages | Not Supported | Not applicable             |
| Integration Type       | Webhook       | Receives data via webhooks |

## Feature Coverage

<AccordionGroup>
  <Accordion title="Streaming Operations" defaultOpen>
    ### Stream Jobs

    **Status:** Not Supported\
    **Method:** `_stream_jobs(updated_after, statuses)`

    Not supported. Jobs are provided via Public API and stored in AtsJobCache. No streaming needed.

    ### Stream Applications

    **Status:** Not Supported\
    **Method:** `_stream_applications(updated_after, for_job_ids)`

    Not supported. Applications are created via Public API calls.

    ### Stream Candidates

    **Status:** Not Supported\
    **Method:** `_stream_candidates(updated_after)`

    Not supported. Candidates are provided via Public API.
  </Accordion>

  <Accordion title="Application Management">
    ### Move Application to Stage

    **Status:** Not Supported\
    **Method:** `_move_application_to_stage(application, stage)`

    Not applicable - stage management handled externally.

    ### Get Disposition Reasons

    **Status:** Not Supported\
    **Method:** `get_disposition_reasons()`

    Not applicable for webhook integration.

    ### Reject Application

    **Status:** Not Supported\
    **Method:** `reject_application(application_id, reason_id)`

    Not applicable - application management handled externally.

    ### Bulk Reject Applications

    **Status:** Not Supported\
    **Method:** `bulk_reject_applications(application_ids, reason_id)`

    Not applicable.

    ### Create Application

    **Status:** Supported (via webhook service)\
    **Method:** `_create_application_for_candidate(candidate, job)`

    Applications are created when customers submit data via the Public API. The integration stores minimal data and sends results via webhooks.

    ### Get All Application Stages

    **Status:** Not Supported\
    **Method:** `_get_all_application_stages()`

    Not applicable.
  </Accordion>

  <Accordion title="Job Management">
    ### Get Job by ID

    **Status:** Supported\
    **Method:** `get_job_by_job_id(job_id)`

    **Implementation Notes:**\
    Retrieves jobs from AtsJobCache that were created via the Public API. Does not query an external ATS.

    ### Get Enhanced Job

    **Status:** Supported (Basic)\
    **Method:** `get_enhanced_job(kombo_id, remote_job_id)`

    Returns cached job data without additional enhancement. No external ATS to query.

    ### Fetch Enhanced Jobs Batch

    **Status:** Not Supported\
    **Method:** `_fetch_enhanced_jobs_batch_from_ats(limit, cursor)`

    Not applicable - jobs come from Public API, not streaming.
  </Accordion>

  <Accordion title="Candidate Management">
    ### Get Candidate by ID

    **Status:** Supported\
    **Method:** `_get_candidate_by_id(candidate_id)`

    **Implementation Notes:**\
    Uses temporary candidate storage (`_temp_candidate`) for processing. Candidate data is provided via Public API.

    ### Find Candidates by Details

    **Status:** Not Supported\
    **Method:** `_find_candidates_by_details(first_name, last_name, email, phone)`

    Not applicable - candidates provided via API, not searched.

    ### Get Resume

    **Status:** Supported\
    **Method:** `_get_resume_for_candidate_id(candidate_id)`

    **Implementation Notes:**\
    Uses temporary resume storage (`_temp_resume`) for processing. Resume data provided via Public API.
  </Accordion>

  <Accordion title="Notes & Attachments">
    ### Add Note to Application

    **Status:** Not Supported\
    **Method:** `_add_note_to_application(application, note, note_action_type)`

    Not applicable - no external ATS to write to.

    ### Add Note to Candidate

    **Status:** Not Supported\
    **Method:** `_add_note_to_candidate(candidate, note, note_action_type)`

    Not applicable.

    ### Add Attachment to Application

    **Status:** Not Supported\
    **Method:** `_add_attachment_to_application(filename, application_id, pdf_b64)`

    Not applicable.

    ### Add Attachment to Candidate

    **Status:** Not Supported\
    **Method:** `_add_attachment_to_candidate(filename, candidate_id, pdf_b64)`

    Not applicable.
  </Accordion>

  <Accordion title="Custom Fields">
    All custom field methods raise `NotImplementedError` as there is no underlying ATS system to manage custom fields.
  </Accordion>
</AccordionGroup>

## Implementation Notes

### Webhook-Based Architecture

The Public API integration works differently from traditional ATS integrations:

1. **Inbound**: Organizations push job and candidate data to Tenzo via Public API
2. **Processing**: Tenzo processes interviews and generates results
3. **Outbound**: Results are sent back via configured webhooks

### Temporary Storage

The client uses temporary storage fields:

* `_temp_candidate`: Stores candidate data during processing
* `_temp_resume`: Stores resume data during processing

### Post-Call Results

Override of `post_call_results()` method sends interview results via webhook instead of writing back to an ATS.

### Job Cache Usage

Jobs created via Public API are stored in `AtsJobCache` and retrieved from there rather than from an external system.

## Webhook Integration

The Public API client integrates with the webhook service (`webhook_service.py`) to:

* Send interview results to customer endpoints
* Notify customers of processing completion
* Deliver structured interview data

## Known Limitations

<Info>
  **Not a Traditional ATS**\
  This integration does not connect to an external ATS system. It's designed for organizations that want to integrate Tenzo via API/webhooks rather than ATS connectivity.
</Info>

<Note>
  **Minimal Implementation**\
  Many methods raise `NotImplementedError` because they don't apply to webhook-based integrations. This is expected and intentional.
</Note>

## Use Cases

The Public API integration is appropriate for:

* Organizations without a traditional ATS
* Custom-built applicant management systems
* Integration with internal HR systems
* Webhook-based workflows

## Related Files

* Implementation: `server/ats/public_api/public_api_ats_client.py`
* Webhook Service: `server/ats/public_api/webhook_service.py`
* Public API Endpoints: `server/ats/public_api/public_api.py`
* Application Controller: `server/ats/public_api/public_application_controller.py`
* Job Controller: `server/ats/public_api/public_job_controller.py`
* README: `server/ats/public_api/README.md`

## See Also

* [ATS Coverage Matrix](/internal/ats-coverage)
* [Public API Documentation](/api-reference/introduction)