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

# Get Company Posts

> Fetch the posts published by a company page with engagement metrics

## Endpoint

```
GET /api/v1/company/posts
```

## Authentication

Include your API key in the request header:

```bash theme={null}
X-API-Key: your-api-key-here
```

## Parameters

<ParamField query="companyUrlOrUrn" type="string" required>
  The company / organization whose posts to fetch. Accepts any of:

  * **Company page URL**. Example: `https://www.linkedin.com/company/microsoft` (a trailing slash makes no difference)
  * **Public identifier (slug)**, also fine. Example: `microsoft`
  * **Organization URN**. Example: `urn:li:fsd_organizationalPage:1035`

  The slug is the last path segment of a company page URL (`/company/<slug>`). Either form works — the bare slug or the `company/<slug>` fragment.

  Member profile inputs (a `/in/<slug>` URL or a `urn:li:fsd_profile:…`) are rejected with a `400` `INVALID_PARAMETER` — "Expected a company page, not a member profile." — free of charge. Use [Get Posts](/api-reference/endpoint/get-posts) for people.
</ParamField>

<ParamField query="profileUrlOrUrn" type="string">
  Accepted as an alternative name for the same value, because
  [Get Posts](/api-reference/endpoint/get-posts) has always taken company pages
  under it. Pass either name — when both are given, `companyUrlOrUrn` wins.
</ParamField>

<ParamField query="count" type="integer" default="10">
  Number of posts to fetch per page.

  * Minimum: 1 — `0` or a negative value is rejected with `400`
  * Maximum: 100 — a higher value is clamped, not rejected
  * Default: 10
</ParamField>

<ParamField query="start" type="integer" default="0" deprecated>
  **Not supported on this endpoint.** This feed is cursor-paginated and ignores
  offsets, so a non-zero `start` is rejected with `400` rather than silently
  returning the first page again. Use `paginationToken`.
</ParamField>

<ParamField query="paginationToken" type="string">
  Cursor for the next page. Pass back the `paginationToken` from the previous
  response, unchanged; omit it to start from the beginning. A value this API did
  not issue is rejected with `400`. Keep paging while `hasMore` is `true`.
</ParamField>

## Response

<ResponseField name="posts" type="array">
  Posts published by the company page, newest first. Each item has the **same
  shape as items from `GET /api/v1/posts`** — see
  [Get Posts](/api-reference/endpoint/get-posts) for the full field list
  (`id`, `shareUrn`, `content`, `date`, `reactionCount`, `commentCount`,
  `sharesCount`, `reactionsByType`, `images`, `video`, `shareUrl`,
  `permissions`, …), so you can reuse the same types in your client code.

  The fields that matter most on a company feed:

  <Expandable title="Post object (company feed essentials)">
    <ResponseField name="id" type="string">
      Activity URN of the post (`urn:li:activity:...`).
    </ResponseField>

    <ResponseField name="content" type="string">
      Post content/text. An empty string when the post carries no text of its own
      — an image, video or document posted without a caption. Always a string,
      never missing.
    </ResponseField>

    <ResponseField name="date" type="string">
      ISO 8601 timestamp of when the post was published.
    </ResponseField>

    <ResponseField name="reactionCount" type="integer">
      Total reactions count (likes, etc.).
    </ResponseField>

    <ResponseField name="commentCount" type="integer">
      Total comments count.
    </ResponseField>

    <ResponseField name="authorType" type="string">
      Always `"Company"` on this endpoint — the author is an organization page,
      not a member.
    </ResponseField>

    <ResponseField name="profile" type="object" required>
      The publishing organization. All fields are always present.

      <Expandable title="Profile object">
        <ResponseField name="name" type="string" required>
          Name of the company page, e.g. "Microsoft"
        </ResponseField>

        <ResponseField name="headline" type="string" required>
          The page's tagline / short descriptor
        </ResponseField>

        <ResponseField name="url" type="string" required>
          Canonical company page URL
        </ResponseField>

        <ResponseField name="imageUrl" type="string" required>
          Company logo image URL
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="paginationToken" type="string">
  Cursor to pass back as `paginationToken` to fetch the next page. Do not read
  its presence as "there is more": decide on `hasMore`, which is the only
  end-of-feed signal on this endpoint.
</ResponseField>

<ResponseField name="hasMore" type="boolean">
  Whether the feed holds more posts behind this page. Keep paging while it is
  `true` — see [Pagination](#pagination).
</ResponseField>

<ResponseField name="pageSize" type="integer">
  How many rows the feed returned for this page **before any filtering** — both
  the reposts the page carries without the organization's own commentary and any
  row that is not a post. Compare it with `posts.length` to tell the two quiet
  cases apart: a small `pageSize` means the feed itself ran short, while a full
  `pageSize` with few posts means this page was mostly filtered rows and it is
  worth asking for the next one.
</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://api.fetchin.io/api/v1/company/posts?companyUrlOrUrn=https://www.linkedin.com/company/microsoft&count=5" \
    -H "X-API-Key: your-api-key-here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    'https://api.fetchin.io/api/v1/company/posts?companyUrlOrUrn=https://www.linkedin.com/company/microsoft&count=5',
    {
      headers: {
        'X-API-Key': 'your-api-key-here'
      }
    }
  );

  const data = await response.json();
  console.log(data.posts);
  ```

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

  headers = {
      'X-API-Key': 'your-api-key-here'
  }

  params = {
      'companyUrlOrUrn': 'https://www.linkedin.com/company/microsoft',
      'count': 5
  }

  response = requests.get(
      'https://api.fetchin.io/api/v1/company/posts',
      headers=headers,
      params=params
  )

  data = response.json()
  print(data['posts'])
  ```

  ```php PHP theme={null}
  <?php

  $apiKey = 'your-api-key-here';
  $companyUrl = 'https://www.linkedin.com/company/microsoft';
  $count = 5;

  $url = "https://api.fetchin.io/api/v1/company/posts?companyUrlOrUrn=" . urlencode($companyUrl) . "&count=" . $count;

  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'X-API-Key: ' . $apiKey
  ]);

  $response = curl_exec($ch);
  $data = json_decode($response, true);

  curl_close($ch);
  print_r($data['posts']);
  ?>
  ```
</CodeGroup>

## Example Response

Posts come back in a page object, not a bare array.

<ResponseExample>
  ```json 200 Success theme={null}
  {
    "posts": [
      {
        "id": "urn:li:activity:7488411205392719872",
        "shareUrn": "urn:li:ugcPost:7488411204611784704",
        "content": "Agents are changing how teams build. Here is what our engineers learned shipping them to production...",
        "date": "2026-07-30T15:02:11.418Z",
        "reactionCount": 3182,
        "commentCount": 212,
        "sharesCount": 184,
        "reactionsByType": {
          "like": 2744,
          "praise": 219,
          "interest": 141,
          "empathy": 78
        },
        "postType": "image",
        "shareUrl": "https://www.linkedin.com/posts/microsoft_agents-are-changing-...",
        "imageUrl": "https://media.licdn.com/dms/image/...",
        "videoUrl": null,
        "carouselPdfUrl": null,
        "images": [
          {
            "url": "https://media.licdn.com/dms/image/...",
            "width": 1920,
            "height": 1080
          }
        ],
        "video": null,
        "authorType": "Company",
        "profile": {
          "urn": "urn:li:fsd_organizationalPage:1035",
          "name": "Microsoft",
          "headline": "Empowering every person and every organization on the planet to achieve more.",
          "url": "https://www.linkedin.com/company/microsoft",
          "imageUrl": "https://media.licdn.com/dms/image/..."
        },
        "permissions": {
          "canReact": true,
          "canPostComments": true,
          "canShare": true,
          "commentingDisabled": false,
          "allowedCommentersScope": "ALL",
          "shareAudience": "PUBLIC",
          "isActivity": false,
          "rootShare": true
        }
      },
      {
        "id": "urn:li:activity:7485109887654321664",
        "shareUrn": "urn:li:share:7485109886654321665",
        "content": "",
        "date": "2026-07-21T09:45:03.117Z",
        "reactionCount": 946,
        "commentCount": 57,
        "sharesCount": 33,
        "reactionsByType": {
          "like": 848,
          "praise": 61,
          "empathy": 37
        },
        "postType": "document",
        "shareUrl": "https://www.linkedin.com/posts/microsoft_...",
        "imageUrl": null,
        "videoUrl": null,
        "carouselPdfUrl": "https://media.licdn.com/dms/document/...",
        "images": [],
        "video": null,
        "authorType": "Company",
        "profile": {
          "urn": "urn:li:fsd_organizationalPage:1035",
          "name": "Microsoft",
          "headline": "Empowering every person and every organization on the planet to achieve more.",
          "url": "https://www.linkedin.com/company/microsoft",
          "imageUrl": "https://media.licdn.com/dms/image/..."
        },
        "permissions": {
          "canReact": true,
          "canPostComments": true,
          "canShare": true,
          "commentingDisabled": false,
          "allowedCommentersScope": "ALL",
          "shareAudience": "PUBLIC",
          "isActivity": false,
          "rootShare": true
        }
      }
    ],
    "paginationToken": "dXJuOmxpOmFjdGl2aXR5Ojc0ODUxMDk4ODc2NTQzMjE2NjQ=",
    "hasMore": true,
    "pageSize": 5
  }
  ```

  ```json 400 Bad Request theme={null}
  {
    "error": "Missing companyUrlOrUrn parameter",
    "code": "MISSING_PARAMETER"
  }
  ```

  ```json 400 Bad Request theme={null}
  {
    "error": "Expected a company page, not a member profile.",
    "code": "INVALID_PARAMETER"
  }
  ```

  ```json 401 Unauthorized theme={null}
  {
    "error": "Invalid API key",
    "code": "INVALID_API_KEY"
  }
  ```

  ```json 404 Not Found theme={null}
  {
    "error": "Unable to find company data from slug",
    "code": "COMPANY_NOT_FOUND"
  }
  ```

  ```json 402 Payment Required theme={null}
  {
    "error": "Quota exceeded. Upgrade your plan or wait for renewal.",
    "code": "QUOTA_EXHAUSTED",
    "details": {
      "creditsRemaining": 0,
      "subscriptionCreditsRemaining": 0,
      "paygCreditsRemaining": 0,
      "buyCreditsUrl": "https://fetchin.io/credits"
    }
  }
  ```

  ```json 500 Internal Server Error theme={null}
  {
    "error": "Internal server error",
    "code": "INTERNAL_ERROR"
  }
  ```

  ```json 503 Service Unavailable theme={null}
  {
    "error": "Service temporarily unable to serve this request. Please retry.",
    "code": "SERVICE_UNAVAILABLE"
  }
  ```
</ResponseExample>

## Errors

See [Error Handling](/concepts/error-handling) for the full list of error codes and recommended handling.

* `400` `MISSING_PARAMETER` / `INVALID_PARAMETER` / `INVALID_URN`
* `401` `INVALID_API_KEY`
* `404` `COMPANY_NOT_FOUND`
* `402` `QUOTA_EXHAUSTED`
* `429` `RATE_LIMITED`
* `500` `INTERNAL_ERROR`
* `503` `SERVICE_UNAVAILABLE`

## Pagination

To walk a company's whole feed:

1. Make an initial request without `paginationToken`
2. If `hasMore` is `true`, pass the returned `paginationToken` into your next request, unchanged
3. Continue until `hasMore` is `false`

```javascript theme={null}
async function fetchAllCompanyPosts(companyUrlOrUrn) {
  const allPosts = [];
  let paginationToken = null;
  let hasMore = true;

  while (hasMore) {
    const params = new URLSearchParams({
      companyUrlOrUrn,
      count: '50'
    });
    if (paginationToken) {
      params.set('paginationToken', paginationToken);
    }

    const response = await fetch(
      `https://api.fetchin.io/api/v1/company/posts?${params}`,
      { headers: { 'X-API-Key': 'your-api-key-here' } }
    );

    const data = await response.json();
    allPosts.push(...data.posts);
    paginationToken = data.paginationToken;
    hasMore = data.hasMore;
  }

  return allPosts;
}
```

## Notes

<Info>
  This endpoint consumes 1 credit from your credit balance per API call, regardless of the `count` parameter value. Errors are free — with one exception: a `404` not found costs 1 credit. See [Quotas](/concepts/quotas).
</Info>

<Warning>
  Posts are returned newest first. `count` is a ceiling, not a promise: the feed
  also carries reposts, which are filtered out of `posts`, so a page can hold
  fewer posts than you asked for while more still remain. A short page is **not**
  the end of the feed — keep paging while `hasMore` is `true`.
</Warning>

<Tip>
  Each item has the same shape as items from
  [Get Posts](/api-reference/endpoint/get-posts), so one set of types and one
  parser covers both a person's feed and a company's.
</Tip>

## Use Cases

<CardGroup cols={2}>
  <Card title="Competitor monitoring" icon="chart-line">
    Track what the accounts you compete with publish, and how their audience responds
  </Card>

  <Card title="Account signals" icon="building">
    Spot hiring pushes, launches and funding news on a target account's own page
  </Card>

  <Card title="Content benchmarking" icon="magnifying-glass">
    Compare reaction and comment counts across company feeds in your market
  </Card>

  <Card title="Brand archive" icon="box-archive">
    Keep a dated record of everything an organization published, media included
  </Card>
</CardGroup>


## OpenAPI

````yaml GET /api/v1/company/posts
openapi: 3.1.0
info:
  title: Fetchin API
  version: 1.0.0
  description: Public B2B data API for fetching posts and profile information
servers:
  - url: https://api.fetchin.io
    description: Production server
security:
  - ApiKeyAuth: []
paths:
  /api/v1/company/posts:
    get:
      summary: Get posts published by a company page
      description: >-
        Fetch the posts published by a company / organization page, newest
        first, with engagement metrics. Each item in `posts` has the same shape
        as items returned by `GET /api/v1/posts`, so the same client types cover
        both feeds. Costs 1 credit per call, whatever `count` is.
      parameters:
        - name: companyUrlOrUrn
          in: query
          required: true
          description: >-
            The company / organization whose posts to fetch. Accepts a company
            page URL (example `https://www.linkedin.com/company/microsoft`; a
            trailing slash is ignored), a public identifier/slug on its own
            (also fine; example `microsoft`), or an organization URN (example
            `urn:li:fsd_organizationalPage:1035`). The slug is the last path
            segment of a company page URL, so pass just the slug, not the
            `/company/` prefix. A member profile input (a `/in/<slug>` URL or a
            `urn:li:fsd_profile:...`) is rejected with a free 400
            INVALID_PARAMETER - "Expected a company page, not a member profile."
            - use `GET /api/v1/posts` for people.
          schema:
            type: string
            example: microsoft
        - name: profileUrlOrUrn
          in: query
          required: false
          description: >-
            Accepted as an alternative name for `companyUrlOrUrn`, because `GET
            /api/v1/posts` has always taken company pages under it. Pass either
            name; when both are given, `companyUrlOrUrn` wins.
          schema:
            type: string
            example: https://www.linkedin.com/company/microsoft
        - name: count
          in: query
          required: false
          description: >-
            Number of posts to fetch per page (default: 10). A higher value is
            clamped to 100.
          schema:
            type: integer
            minimum: 1
            maximum: 100
            default: 10
        - name: start
          in: query
          required: false
          description: >-
            Not supported on this endpoint. This feed is cursor-paginated and
            ignores offsets, so a non-zero value is rejected with 400 rather
            than silently returning the first page again. Page with
            `paginationToken` instead.
          schema:
            type: integer
            minimum: 0
            default: 0
          deprecated: true
        - name: paginationToken
          in: query
          required: false
          description: >-
            Cursor for the next page: pass back the `paginationToken` from the
            previous response, unchanged. Omit it to start from the beginning. A
            value this API did not issue is rejected with 400. Keep paging while
            `hasMore` is true.
          schema:
            type: string
      responses:
        '200':
          description: Successfully fetched the company page's posts
          content:
            application/json:
              schema:
                type: object
                properties:
                  posts:
                    type: array
                    description: >-
                      Posts on this page, newest first. Same item shape as GET
                      /api/v1/posts. Reposts are filtered out, so a page can
                      hold fewer items than `count` while more remain - trust
                      `hasMore`.
                    items:
                      type: object
                      properties:
                        id:
                          type: string
                          example: urn:li:activity:7488411205392719872
                          description: >-
                            Activity URN. References the post in the
                            `urn:li:activity:*` namespace.
                        shareUrn:
                          type: string
                          example: urn:li:ugcPost:7488411204611784704
                          description: >-
                            Share URN. References the same post as `id` but in
                            the `urn:li:share:*` or `urn:li:ugcPost:*` namespace
                            (depends on the post type).
                        content:
                          type: string
                          example: Agents are changing how teams build...
                          description: >-
                            Post text. An empty string when the post carries no
                            text of its own (media posted without a caption).
                            Always a string, never missing.
                        date:
                          type: string
                          format: date-time
                        reactionCount:
                          type: integer
                        commentCount:
                          type: integer
                        sharesCount:
                          type: integer
                          description: Number of times the post was reshared.
                        imageUrl:
                          type: string
                        videoUrl:
                          type: string
                        carouselPdfUrl:
                          type: string
                        profile:
                          type: object
                          description: >-
                            The publishing organization. All fields are always
                            present.
                          required:
                            - urn
                            - name
                            - headline
                            - url
                            - imageUrl
                          properties:
                            urn:
                              type: string
                              example: urn:li:fsd_organizationalPage:1035
                            name:
                              type: string
                              example: Microsoft
                              description: Name of the company page.
                            headline:
                              type: string
                              example: >-
                                Empowering every person and every organization
                                on the planet to achieve more.
                              description: The page's tagline / short descriptor.
                            url:
                              type: string
                              example: https://www.linkedin.com/company/microsoft
                              description: Canonical company page URL.
                            imageUrl:
                              type: string
                              example: https://media.licdn.com/dms/image/...
                              description: Company logo image URL.
                        postType:
                          type: string
                          enum:
                            - text
                            - image
                            - document
                            - article
                            - linkedinVideo
                          example: image
                          description: Kind of content attached to the post.
                        shareUrl:
                          type: string
                          example: >-
                            https://www.linkedin.com/posts/microsoft_agents-are-changing-...
                          description: Public permalink to the post.
                        reactionsByType:
                          type: object
                          description: >-
                            Reaction counts broken down by type. Only the types
                            the post actually received are present, and they sum
                            to `reactionCount`.
                          additionalProperties:
                            type: integer
                          example:
                            like: 2744
                            praise: 219
                            interest: 141
                            empathy: 78
                        images:
                          type: array
                          description: >-
                            Every image of the post with its dimensions (empty
                            for non-image posts). `imageUrl` is the first one,
                            kept for backward compatibility.
                          items:
                            type: object
                            properties:
                              url:
                                type: string
                                example: https://media.licdn.com/dms/image/...
                              width:
                                type: integer
                                example: 1920
                              height:
                                type: integer
                                example: 1080
                        video:
                          type:
                            - object
                            - 'null'
                          description: >-
                            Video attached to the post, or null. `videoUrl`
                            mirrors `video.url`.
                          properties:
                            url:
                              type: string
                              example: https://dms.licdn.com/playlist/vid/...
                            duration:
                              type: integer
                              example: 74000
                              description: Duration in milliseconds.
                            thumbnail:
                              type:
                                - string
                                - 'null'
                            progressiveStreams:
                              type: array
                              description: >-
                                Available renditions (bitrate/resolution
                                variants).
                              items:
                                type: object
                        authorType:
                          type: string
                          enum:
                            - Company
                          example: Company
                          description: >-
                            Always `Company` on this endpoint: the author is an
                            organization page, not a member.
                        permissions:
                          type: object
                          description: What the post allows, as published.
                          properties:
                            canReact:
                              type: boolean
                            canPostComments:
                              type: boolean
                            canShare:
                              type: boolean
                            commentingDisabled:
                              type: boolean
                            allowedCommentersScope:
                              type: string
                              example: ALL
                            shareAudience:
                              type: string
                              example: PUBLIC
                            isActivity:
                              type: boolean
                            rootShare:
                              type: boolean
                              description: False when the post quotes another one.
                  paginationToken:
                    type:
                      - string
                      - 'null'
                    example: dXJuOmxpOmFjdGl2aXR5Ojc0ODUxMDk4ODc2NTQzMjE2NjQ=
                    description: >-
                      Cursor to pass back as `paginationToken` to fetch the next
                      page. Only present when more posts are available.
                  hasMore:
                    type: boolean
                    description: >-
                      Whether the feed holds more posts behind this page. Keep
                      paging while true.
                  pageSize:
                    type: integer
                    example: 5
                    description: >-
                      How many rows the feed returned for this page before
                      reposts were filtered out of `posts`. Compare it with the
                      length of `posts` to tell a feed that ran short from a
                      page that happened to be mostly reposts.
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '402':
          $ref: '#/components/responses/PaymentRequired'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
components:
  responses:
    BadRequest:
      description: Bad request - a required parameter is missing or a value is invalid.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            missingParameter:
              value:
                error: Missing profileUrlOrUrn parameter
                code: MISSING_PARAMETER
            invalidParameter:
              value:
                error: limit must be a number between 1 and 100
                code: INVALID_PARAMETER
            invalidUrn:
              value:
                error: 'Invalid URN format: urn:li:member:123456789'
                code: INVALID_URN
    Unauthorized:
      description: Unauthorized - the X-API-Key header is missing or invalid.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            missingApiKey:
              value:
                error: Missing API key. Include X-API-Key header.
                code: UNAUTHENTICATED
            invalidApiKey:
              value:
                error: Invalid API key
                code: INVALID_API_KEY
    PaymentRequired:
      description: >-
        Payment required - you are out of credits (QUOTA_EXHAUSTED): the plan
        allowance for the current period is spent AND no pay-as-you-go credits
        are left. Buy pay-as-you-go credits (self-serve,
        https://fetchin.io/credits), upgrade your plan, or wait for renewal;
        retrying will not help and no Retry-After is sent. Distinct from the
        per-second rate limit, which is a 429 (RATE_LIMITED).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            quotaExhausted:
              value:
                error: Quota exceeded. Upgrade your plan or wait for renewal.
                code: QUOTA_EXHAUSTED
                details:
                  creditsRemaining: 0
                  subscriptionCreditsRemaining: 0
                  paygCreditsRemaining: 0
                  buyCreditsUrl: https://fetchin.io/credits
    NotFound:
      description: >-
        Not found - the request was served successfully but the requested
        professional entity does not exist.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            profileNotFound:
              value:
                error: LinkedIn profile not found
                code: PROFILE_NOT_FOUND
            postNotFound:
              value:
                error: Unable to find post from url
                code: POST_NOT_FOUND
            companyNotFound:
              value:
                error: Unable to find company slug from urn
                code: COMPANY_NOT_FOUND
    TooManyRequests:
      description: >-
        Too many requests - your per-second rate limit (RATE_LIMITED) was
        exceeded. Back off and retry, honoring the Retry-After header. (Running
        out of credits is a separate 402 PaymentRequired / QUOTA_EXHAUSTED, and
        buying credits never raises this per-second limit.)
      headers:
        Retry-After:
          description: Number of seconds to wait before retrying the request.
          schema:
            type: integer
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            rateLimited:
              value:
                error: Rate limit exceeded. Try again later.
                code: RATE_LIMITED
    InternalError:
      description: >-
        Internal server error - an unexpected error occurred in our API. Safe to
        retry; contact support if it persists.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            internalError:
              value:
                error: Internal server error
                code: INTERNAL_ERROR
    ServiceUnavailable:
      description: >-
        Service unavailable - our API is temporarily unable to serve this
        request (capacity exhausted or overloaded). This is on our side, not
        yours and not an upstream service outage. Retry with backoff, honoring
        the Retry-After header.
      headers:
        Retry-After:
          description: Number of seconds to wait before retrying the request.
          schema:
            type: integer
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            serviceUnavailable:
              value:
                error: >-
                  Service temporarily unable to serve this request. Please
                  retry.
                code: SERVICE_UNAVAILABLE
  schemas:
    Error:
      type: object
      required:
        - error
        - code
      properties:
        error:
          type: string
          description: >-
            Human-readable description of what went wrong. For display/logging;
            do not branch on this string.
        code:
          type: string
          enum:
            - MISSING_PARAMETER
            - INVALID_PARAMETER
            - INVALID_URN
            - UNAUTHENTICATED
            - INVALID_API_KEY
            - FORBIDDEN
            - NOT_FOUND
            - PROFILE_NOT_FOUND
            - POST_NOT_FOUND
            - COMPANY_NOT_FOUND
            - ENDPOINT_REMOVED
            - RATE_LIMITED
            - QUOTA_EXHAUSTED
            - INTERNAL_ERROR
            - UPSTREAM_ERROR
            - SERVICE_UNAVAILABLE
            - UPSTREAM_TIMEOUT
          description: >-
            Stable, machine-readable error code. Branch your integration on this
            value, not on the HTTP status alone or the message text.
        details:
          type: object
          additionalProperties: true
          description: >-
            Optional structured context. On QUOTA_EXHAUSTED it carries the
            balance breakdown at the moment of the rejection - creditsRemaining,
            subscriptionCreditsRemaining, paygCreditsRemaining - plus
            buyCreditsUrl, the self-serve page for buying more credits. Always
            additive and never guaranteed: read it for diagnostics and logs, but
            branch on `code` and do not require any field of it.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-Key

````

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