---
updatedAt: 2026-08-24T09:14:57.000Z
agentTools:
  projectIndex: https://developers.vibe.co/llms.txt
---

# List persistent audiences available for sync

**Scopes:**
`audiences:read`
<br>*Rate limits*:<br>Burst: `10/s`<br>Steady: `300/m`


# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "paths": {
    "/audiences": {
      "get": {
        "operationId": "listAudiences",
        "parameters": [
          {
            "name": "advertiser_id",
            "required": true,
            "in": "query",
            "description": "Stable identifier of the advertiser used to filter audiences",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "limit",
            "required": false,
            "in": "query",
            "description": "Maximum number of audiences to return",
            "schema": {
              "minimum": 1,
              "default": 20,
              "type": "number"
            }
          },
          {
            "name": "offset",
            "required": false,
            "in": "query",
            "description": "Zero-based number of audiences to skip before returning results",
            "schema": {
              "minimum": 0,
              "default": 0,
              "type": "number"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Audience list response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AudienceList"
                }
              }
            }
          },
          "400": {
            "description": "Bad request error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                },
                "examples": {
                  "missingApiKey": {
                    "summary": "Missing API key",
                    "value": {
                      "error": {
                        "type": "validation",
                        "message": "Missing API Key",
                        "status": 400,
                        "detail": null,
                        "request_id": "req_8f3a4b2c",
                        "doc_url": null
                      }
                    }
                  },
                  "validationError": {
                    "summary": "Validation error",
                    "value": {
                      "error": {
                        "type": "validation",
                        "message": "Validation error",
                        "status": 400,
                        "detail": {
                          "validation": [
                            "id must be a string"
                          ]
                        },
                        "request_id": "req_8f3a4b2c",
                        "doc_url": null
                      }
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                },
                "examples": {
                  "invalidApiKey": {
                    "summary": "Invalid API key",
                    "value": {
                      "error": {
                        "type": "invalid_token",
                        "message": "Unauthorized",
                        "status": 401,
                        "detail": null,
                        "request_id": "req_8f3a4b2c",
                        "doc_url": "https://developers.vibe.co/errors/invalid-token"
                      }
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Insufficient scope error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                },
                "examples": {
                  "insufficientScope": {
                    "summary": "Missing required scope",
                    "value": {
                      "error": {
                        "type": "insufficient_scope",
                        "message": "Missing required scope",
                        "status": 403,
                        "detail": {
                          "required": "audiences:read",
                          "granted": [
                            "test"
                          ]
                        },
                        "request_id": "req_8f3a4b2c",
                        "doc_url": "https://developers.vibe.co/reference/oauth2token"
                      }
                    }
                  }
                }
              }
            }
          }
        },
        "summary": "List persistent audiences available for sync",
        "tags": [
          "Audiences"
        ],
        "x-rate-limit": {
          "rps": 10,
          "rpm": 300
        },
        "x-scopes": [
          "audiences:read"
        ],
        "description": "**Scopes:**\n`audiences:read`\n<br>*Rate limits*:<br>Burst: `10/s`<br>Steady: `300/m`\n"
      }
    }
  },
  "info": {
    "title": "Vibe Public API",
    "description": "Vibe Public API revision 2026-06-01",
    "version": "2026-06-01",
    "contact": {}
  },
  "tags": [
    {
      "name": "Audiences",
      "description": "An Audience is a list of user identifiers Vibe can target or exclude. You populate an audience by opening a **sync**, uploading one or more **batches** of identifiers, then marking the final batch with `last_batch_flag: true`.\n\nConcurrency: only one non-terminal sync may exist per audience at a time. Syncs expire after 24 hours of inactivity.\n\n> ⚠️ **Gotcha — silent zero-match failures**\n>\n> If your identifiers are hashed with the wrong algorithm or normalization, the sync will succeed and the audience will show as Active, but it will match zero CTV profiles. There is no error signal. See the [HEM format specification](https://developers.vibe.co/docs/hem-format) for the exact requirements."
    }
  ],
  "servers": [
    {
      "url": "https://api.vibe.co",
      "description": "Production API"
    }
  ],
  "components": {
    "securitySchemes": {
      "bearer": {
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "type": "http"
      }
    },
    "schemas": {
      "ErrorDetail": {
        "type": "object",
        "properties": {
          "required": {
            "type": "string",
            "example": "audiences:write"
          },
          "granted": {
            "example": [
              "audiences:read",
              "reporting:read"
            ],
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "required",
          "granted"
        ]
      },
      "ApiError": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "insufficient_scope",
              "invalid_token",
              "validation",
              "internal_error"
            ]
          },
          "message": {
            "type": "string"
          },
          "status": {
            "type": "number",
            "example": 403
          },
          "detail": {
            "nullable": true,
            "allOf": [
              {
                "$ref": "#/components/schemas/ErrorDetail"
              }
            ]
          },
          "request_id": {
            "type": "string",
            "example": "req_8f3a4b2c"
          },
          "doc_url": {
            "type": "string",
            "example": "https://developers.vibe.co/reference/oauth2token",
            "nullable": true
          }
        },
        "required": [
          "type",
          "message",
          "status",
          "request_id"
        ]
      },
      "ErrorResponse": {
        "type": "object",
        "properties": {
          "error": {
            "$ref": "#/components/schemas/ApiError"
          }
        },
        "required": [
          "error"
        ]
      },
      "AudienceListItem": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid",
            "description": "Stable identifier of the audience"
          },
          "advertiser_id": {
            "type": "string",
            "format": "uuid",
            "description": "Stable identifier of the advertiser this audience belongs to"
          },
          "application_id": {
            "type": "string",
            "format": "uuid",
            "description": "Stable identifier of the application this audience belongs to"
          },
          "name": {
            "type": "string",
            "description": "Display name for the audience"
          },
          "external_audience_key": {
            "type": "string",
            "description": "Caller-provided stable key used to upsert the audience"
          },
          "status": {
            "type": "string",
            "description": "Current audience status",
            "enum": [
              "ACTIVE",
              "INACTIVE"
            ]
          }
        },
        "required": [
          "id",
          "advertiser_id",
          "application_id",
          "name",
          "status"
        ]
      },
      "AudienceList": {
        "type": "object",
        "properties": {
          "data": {
            "description": "List of audiences matching the request",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/AudienceListItem"
            }
          },
          "total": {
            "type": "number",
            "description": "Total number of audiences matching the filters"
          },
          "limit": {
            "type": "number",
            "description": "Maximum number of items returned"
          },
          "offset": {
            "type": "number",
            "description": "Number of items skipped"
          }
        },
        "required": [
          "data",
          "total",
          "limit",
          "offset"
        ]
      }
    }
  },
  "security": [
    {
      "bearer": []
    }
  ]
}
```