In Feast, each batch data source is associated with corresponding offline stores. For example, a SnowflakeSource can only be processed by the Snowflake offline store, while a FileSource can be processed by both File and DuckDB offline stores. Otherwise, the primary difference between batch data sources is the set of supported types. Feast has an internal type system that supports primitive types (bytes, string, int32, int64, float32, float64, bool, timestamp), array types, set types, map/JSON types, and struct types. However, not every batch data source supports all of these types.

For more details on the Feast type system, see here.

By default, every data source inherits connection credentials from the global feature_store.yaml offline store configuration. The ConnectionRef feature allows each data source to declare its own external credential reference, enabling:

• Multi-tenant deployments where different feature views access different accounts or databases.
• Credential isolation where secrets are resolved at runtime from external providers (Kubernetes Secrets, HashiCorp Vault, environment variables) rather than stored in configuration files.
• Hybrid offline store routing where a single Feast deployment connects to multiple backends, each with independent credentials.

A ConnectionRef is attached to any data source via the connection_ref parameter:

from feast.credentials import ConnectionRef
from feast.infra.offline_stores.snowflake_source import SnowflakeSource

source = SnowflakeSource(
    table="USER_FEATURES",
    connection_ref=ConnectionRef(
        provider="kubernetes",
        name="snowflake-creds",
        namespace="ml-team",
        connection_type="snowflake.offline",
        auth_type="secret",
        params={"account": "xy12345", "warehouse": "COMPUTE_WH"},
    ),
)

Feast ships with built-in providers that can be registered at startup:

Custom providers can be registered via:

from feast.credentials import register_credential_provider, CredentialProvider, ConnectionRef

class MyProvider(CredentialProvider):
    def provider_type(self) -> str:
        return "my-provider"

    def resolve(self, ref: ConnectionRef) -> dict:
        # Return key-value credential pairs
        return {"username": "...", "password": "..."}

register_credential_provider(MyProvider())

1. When an offline store needs to connect, it checks whether the data source has a connection_ref.
2. If present, credentials are resolved from the external provider at runtime.
3. Resolved credentials (and any params from the ConnectionRef) are merged and used to override the global offline store configuration for that specific operation.
4. If no connection_ref is set, the data source uses the global feature_store.yaml configuration as before.

For usage with the Hybrid Offline Store, see Hybrid Offline Store.

There are currently four core batch data source implementations: FileSource, BigQuerySource, SnowflakeSource, and RedshiftSource. There are several additional implementations contributed by the Feast community (PostgreSQLSource, SparkSource, and TrinoSource), which are not guaranteed to be stable or to match the functionality of the core implementations. Details for each specific data source can be found here.

Below is a matrix indicating which data sources support which types.

* Set types are defined in Feast's proto and Python type system but are not inferred by any backend. They must be explicitly declared in the feature view schema and are best suited for online serving use cases. See Type System for details.