Streams is the engine that handles delivering data from Yext source systems to consumer-facing applications like Search, Pages, and Listings. It processes all updates to data and regenerates only the records affected by those updates, so downstream systems always receive current data without re-processing the entire dataset.

To use Streams in an external application, you define a Content Endpoint. Once defined, you can fetch data from that endpoint via the Content API, or configure a Content Webhook to receive updates automatically when the data changes.

Note: Stream configuration always exists in the context of a downstream system. You never configure a stream independently — you configure it as part of a Content Endpoint, a Pages site, or a Search experience.

Key Concepts

Stream Properties

When configuring a Stream (for Content Endpoints or Pages sites), the following properties apply:

Content API

The Content API is used to fetch data from Content Endpoints for use in consumer experiences. Because data is pre-processed according to the Content Endpoint configuration, queries are extremely fast. There is no requirement to traverse the graph in real time.

Base URLs

As with most other Yext endpoints intended for reading data, there is a Get by ID and List version of requests to Content Endpoints.

All requests require a v param and an api_key as query parameters.

Get by ID

Returns a single record by its primary key. Get by ID is more performant than a List request. You can include multiple IDs in a single request, separated by commas or semicolons.

The primary key varies by source:

Example:

GET

https://cdn.yextapis.com/v2/accounts/me/api/exampleEndpoint/id1;id2;id3?api_key={api_key}&v=20200408

List

The Content API provides the ability for a user to filter and sort records by the contents of an indexed field. The filters and sorting parameters can be provided as query parameters, in addition to the query parameters documented here. If no filters are provided, the API returns all the records (with pagination).

For example:

GET https://cdn.yextapis.com/v2/accounts/me/api/exampleEndpoint/?api_key={api_key}&v=2020040&name=EntityA

only records where the field name has value EntityA will be returned.

Additionally, the Content API can support OR logic on a single field, allowing a requester to pass multiple values for a single field. For example, if you only wanted entities where name=EntityA OR name=EntityB, the request would be:

GET https://cdn.yextapis.com/v2/accounts/me/api/exampleEndpoint/?api_key={api_key}&v=2020040&name__in=EntityA&name__in=EntityB

Filters

Filters are supported on Text, Numeric, Date and DateTime fields, although not all filters are supported by all fields.

It is also possible to filter on an array of strings, or a string field nested in an array of objects. In this case, the record will be present in the response if one of the field values in the array matches the filter.

For example, consider the following records produced for a Content Endpoint:

[
   {
      "uid":123,
      "c_listOfColors":[
         "red",
         "blue",
         "green"
      ]
   },
   {
      "id":456,
      "c_listOfColors":[
         "red",
         "yellow"
      ]
   }
]

If you made a request to this endpoint and filtered for c_listOfColors=blue, only the record with uid=123 would be returned, since the c_listOfColors array on that record contains “blue”.

Fields from related entities are accessed via a projection (using dot notation) will be made available in an array of objects.

For example, in the following record produced for a Content Endpoint, where c_linkedVariants is an entity relationship field. If you made a request to this endpoint and filtered for c_linkedVariants.size=32oz, only the record with uid=234 would be returned, since the c_linkedVariants array on that record contains the value “32oz” in the “size” field.

[
   {
      "uid":234,
      "name":"Product A",
      "c_linkedVariants":[
         {
            "size":"32oz",
            "color":"Blue"
         },
         {
            "size":"40oz",
            "color":"Yellow"
         }
      ]
   },
   {
      "uid":234,
      "name":"Product A",
      "c_linkedVariants":[
         {
            "size":"20oz",
            "color":"Red"
         },
         {
            "size":"48oz",
            "color":"Orange"
         }
      ]
   }
]

If you made a request to this endpoint and filtered for c_linkedVariants.size=32oz, only the record with uid=234 would be returned, since the c_linkedVariants array on that record contains the value “32oz” in the “size” field.

However, the Content API is not able to ensure that multiple values in a single object match a filter criteria; it is only evaluating whether the values exist in the array at all, not limited to within a single object. For example, if you filtered to c_linkedVariants.size=32oz&c_linkedVariants.color=Yellow, the record with uid=234 would still be returned. Technically, both these criteria are met within the record, despite the fact that the criteria are not both met within a single object.

Limits

• Maximum stream size: 1.5 MB
• Maximum indexed/searchable file content in Yext Search: 100 KB

Content Webhooks

Content Webhooks allow applications to receive data updates via a push flow, rather than polling the Content API. A webhook sends a POST message to a destination URL whenever any field included in the selected Content Endpoint changes.

Like the Content API, Content Webhooks are based on Content Endpoints. If you only need webhook delivery (not API querying), you do not need to index any fields in the endpoint configuration.