*January 26, 2026* | *Nikhil Kathole, Francisco Javier Arceo*

Understanding where your ML features come from and how they flow through your system is critical for debugging, compliance, and governance. We are excited to announce that Feast now supports native integration with [OpenLineage](https://openlineage.io/), the open standard for data lineage collection and analysis.

With this integration, Feast automatically tracks and emits lineage events whenever you apply feature definitions or materialize features—**no code changes required**. Simply enable OpenLineage in your `feature_store.yaml`, and Feast handles the rest.

Feature stores manage the lifecycle of ML features, from raw data sources to model inference. As ML systems grow in complexity, teams often struggle to answer fundamental questions:

- *Where does this feature's data come from?*

- *Which models depend on this feature view?*

- *What downstream impact will changing this data source have?*

- *How do I audit the data flow for compliance?*

OpenLineage solves these challenges by providing a standardized way to capture and visualize data lineage. By integrating OpenLineage into Feast, ML teams gain automatic visibility into their feature engineering pipelines without manual instrumentation.

The integration automatically emits OpenLineage events for two key operations:

When you run `feast apply`, Feast creates a lineage graph that mirrors what you see in the Feast UI:

This creates two types of jobs:

- **`feast_feature_views_{project}`**: Shows how DataSources and Entities flow into FeatureViews

- **`feature_service_{name}`**: Shows which FeatureViews compose each FeatureService

When materializing features, Feast emits START, COMPLETE, and FAIL events, allowing you to track:

- Which feature views were materialized

- The time window of materialization

- Success or failure status

- Duration and row counts

pip install feast[openlineage]

Add the `openlineage` section to your `feature_store.yaml`:

project: my_fraud_detection

registry: data/registry.db

provider: local

online_store:

type: sqlite

path: data/online_store.db

openlineage:

enabled: true

transport_type: http

transport_url: http://localhost:5000

namespace: feast

from feast import FeatureStore

fs = FeatureStore(repo_path="feature_repo")

fs.apply([

driver_entity,

driver_stats_source,

driver_hourly_stats_view,

driver_stats_service

])

Visit http://localhost:3000 to see your lineage graph in Marquez!

The integration doesn't just track relationships—it captures comprehensive metadata about your Feast objects:

- Feature names, types, and descriptions

- TTL (time-to-live) configuration

- Associated entities

- Custom tags

- Online/offline store enablement

- Constituent feature views

- Total feature count

- Service-level descriptions and tags

- Source type (File, BigQuery, Snowflake, etc.)

- Connection URIs

- Timestamp fields

- Field mappings

All this metadata is attached as OpenLineage facets, making it queryable and explorable in any OpenLineage-compatible tool.

We've included a complete working example in the Feast repository that demonstrates the OpenLineage integration end-to-end. The example creates a driver statistics feature store and shows how lineage events are automatically emitted.

**Run the example:**

docker run -p 5000:5000 -p 3000:3000 marquezproject/marquez

cd feast/examples/openlineage-integration

python openlineage_demo.py --url http://localhost:5000

The example demonstrates:

- Creating entities, data sources, feature views, and feature services

- Automatic lineage emission on `feast apply`

- Materialization tracking with START/COMPLETE events

- Feature retrieval (no lineage events for retrieval operations)

In Marquez, you'll see the complete lineage graph:

- `driver_stats_source` (DataSource) → `driver_hourly_stats` (FeatureView)

- `driver_id` (Entity) → `driver_hourly_stats` (FeatureView)

- `driver_hourly_stats` (FeatureView) → `driver_stats_service` (FeatureService)

Check out the [full example code](https://github.com/feast-dev/feast/tree/master/examples/openlineage-integration) for complete details including feature definitions with descriptions and tags

When a model's predictions degrade, trace back through the lineage to identify which data source or feature transformation changed.

Before modifying a data source, understand all downstream feature views and services that will be affected.

Maintain a complete audit trail of data flow for regulatory requirements like GDPR, CCPA, or SOC2.

Auto-generated lineage serves as living documentation that stays in sync with your actual feature store configuration.

Data engineers, ML engineers, and data scientists can all view the same lineage graph to understand the feature store structure.

Data lineage is becoming essential for production ML systems. With Feast's OpenLineage integration, you get automatic lineage tracking without any code changes. Combined with visualization tools like Marquez, teams can finally answer "where does this data come from?" with confidence.

This integration is available now in the latest version of Feast. We're excited to see how teams use it to improve their ML operations and welcome feedback from the community.

To get started, check out the [OpenLineage Integration documentation](../reference/openlineage.md) and the [example in the Feast repository](https://github.com/feast-dev/feast/tree/master/examples/openlineage-integration).