diff --git a/go.mod b/go.mod
index 787991a3d..33c081b29 100644
--- a/go.mod
+++ b/go.mod
@@ -37,7 +37,7 @@ require (
 	github.com/iFaceless/godub v0.0.0-20200728093528-a30bb4d1a0f1
 	github.com/iancoleman/strcase v0.3.0
 	github.com/influxdata/influxdb-client-go/v2 v2.12.3
-	github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241007141417-545e5d187408
+	github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241011110226-54b40c98b2f0
 	github.com/instill-ai/usage-client v0.2.4-alpha.0.20240123081026-6c78d9a5197a
 	github.com/instill-ai/x v0.5.0-alpha
 	github.com/itchyny/gojq v0.12.14
diff --git a/go.sum b/go.sum
index 27c17d112..59eb41e21 100644
--- a/go.sum
+++ b/go.sum
@@ -1277,6 +1277,8 @@ github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 h1:W9WBk7
 github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
 github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241007141417-545e5d187408 h1:GTx0g6dXxd7WUm4bvJK1N+j8zuxIaSoXD5AZ2Vl+FXI=
 github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241007141417-545e5d187408/go.mod h1:rf0UY7VpEgpaLudYEcjx5rnbuwlBaaLyD4FQmWLtgAY=
+github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241011110226-54b40c98b2f0 h1:1h67FkayaXU/ona9m1VZjrQ8Wj8NR05ytxFvUSjIEi4=
+github.com/instill-ai/protogen-go v0.3.3-alpha.0.20241011110226-54b40c98b2f0/go.mod h1:rf0UY7VpEgpaLudYEcjx5rnbuwlBaaLyD4FQmWLtgAY=
 github.com/instill-ai/usage-client v0.2.4-alpha.0.20240123081026-6c78d9a5197a h1:gmy8BcCFDZQan40c/D3f62DwTYtlCwi0VrSax+pKffw=
 github.com/instill-ai/usage-client v0.2.4-alpha.0.20240123081026-6c78d9a5197a/go.mod h1:EpX3Yr661uWULtZf5UnJHfr5rw2PDyX8ku4Kx0UtYFw=
 github.com/instill-ai/x v0.5.0-alpha h1:xIeIvrLzwJYOBmZwOePVFVkKGEcMDqtHmn1cfVVNlIE=
diff --git a/pkg/datamodel/runlogging.go b/pkg/datamodel/runlogging.go
index 645b165d3..6c4f38f4f 100644
--- a/pkg/datamodel/runlogging.go
+++ b/pkg/datamodel/runlogging.go
@@ -67,6 +67,7 @@ func (j *JSONB) Scan(value interface{}) error {
 type PipelineRun struct {
 	PipelineTriggerUID uuid.UUID      `gorm:"primaryKey" json:"pipeline-trigger-uid"`                                        // Unique identifier for each run
 	PipelineUID        uuid.UUID      `gorm:"type:uuid;index" json:"pipeline-uid"`                                           // Pipeline unique ID used in the run
+	Pipeline           Pipeline       `gorm:"foreignKey:PipelineUID;references:UID"`                                         // Pipeline instance referenced in the run
 	PipelineVersion    string         `gorm:"type:varchar(255)" json:"pipeline-version"`                                     // Pipeline version used in the run
 	Status             RunStatus      `gorm:"type:valid_trigger_status;index" json:"status"`                                 // Current status of the run (e.g., Running, Completed, Failed)
 	Source             RunSource      `gorm:"type:valid_trigger_source" json:"source"`                                       // Origin of the run (e.g., Web click, API)
diff --git a/pkg/handler/pipeline.go b/pkg/handler/pipeline.go
index e01719ec8..84b434a6e 100644
--- a/pkg/handler/pipeline.go
+++ b/pkg/handler/pipeline.go
@@ -1996,3 +1996,37 @@ func (h *PublicHandler) ListComponentRuns(ctx context.Context, req *pb.ListCompo
 
 	return resp, nil
 }
+
+func (h *PublicHandler) ListPipelineRunsByCreditOwner(ctx context.Context, req *pb.ListPipelineRunsByCreditOwnerRequest) (*pb.ListPipelineRunsByCreditOwnerResponse, error) {
+	logger, _ := logger.GetZapLogger(ctx)
+	logUUID, _ := uuid.NewV4()
+	logger.Info("ListPipelineRunsByCreditOwner starts", zap.String("logUUID", logUUID.String()))
+
+	if req.GetStart().IsValid() && req.GetStop().IsValid() && req.GetStart().AsTime().After(req.GetStop().AsTime()) {
+		return nil, fmt.Errorf("input stop time earlier than start time")
+	}
+
+	declarations, err := filtering.NewDeclarations([]filtering.DeclarationOption{
+		filtering.DeclareStandardFunctions(),
+		filtering.DeclareIdent("status", filtering.TypeString),
+		filtering.DeclareIdent("source", filtering.TypeString),
+	}...)
+	if err != nil {
+		return nil, err
+	}
+
+	filter, err := filtering.ParseFilter(req, declarations)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := h.service.ListPipelineRunsByCreditOwner(ctx, req, filter)
+	if err != nil {
+		logger.Error("failed in ListPipelineRunsByCreditOwner", zap.String("logUUID", logUUID.String()), zap.Error(err))
+		return nil, status.Error(codes.Internal, "Failed to list pipeline runs")
+	}
+
+	logger.Info("ListPipelineRunsByCreditOwner finished", zap.String("logUUID", logUUID.String()))
+
+	return resp, nil
+}
diff --git a/pkg/mock/repository_mock.gen.go b/pkg/mock/repository_mock.gen.go
index fa1f0f42b..63fb600ad 100644
--- a/pkg/mock/repository_mock.gen.go
+++ b/pkg/mock/repository_mock.gen.go
@@ -6,17 +6,21 @@ import (
 	"context"
 	"sync"
 	mm_atomic "sync/atomic"
+	"time"
 	mm_time "time"
 
 	"github.com/gofrs/uuid"
 	"github.com/gojuno/minimock/v3"
-	"github.com/instill-ai/pipeline-backend/pkg/datamodel"
-	mm_repository "github.com/instill-ai/pipeline-backend/pkg/repository"
-	pb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 	"go.einride.tech/aip/filtering"
 	"go.einride.tech/aip/ordering"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
+
+	"github.com/instill-ai/pipeline-backend/pkg/datamodel"
+
+	mm_repository "github.com/instill-ai/pipeline-backend/pkg/repository"
+
+	pb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
 
 // RepositoryMock implements mm_repository.Repository
@@ -171,6 +175,13 @@ type RepositoryMock struct {
 	beforeGetPaginatedComponentRunsByPipelineRunIDWithPermissionsCounter uint64
 	GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock          mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions
 
+	funcGetPaginatedPipelineRunsByCreditOwner          func(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (pa1 []datamodel.PipelineRun, i1 int64, err error)
+	funcGetPaginatedPipelineRunsByCreditOwnerOrigin    string
+	inspectFuncGetPaginatedPipelineRunsByCreditOwner   func(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy)
+	afterGetPaginatedPipelineRunsByCreditOwnerCounter  uint64
+	beforeGetPaginatedPipelineRunsByCreditOwnerCounter uint64
+	GetPaginatedPipelineRunsByCreditOwnerMock          mRepositoryMockGetPaginatedPipelineRunsByCreditOwner
+
 	funcGetPaginatedPipelineRunsWithPermissions          func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) (pa1 []datamodel.PipelineRun, i1 int64, err error)
 	funcGetPaginatedPipelineRunsWithPermissionsOrigin    string
 	inspectFuncGetPaginatedPipelineRunsWithPermissions   func(ctx context.Context, requesterUID string, pipelineUID string, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool)
@@ -446,6 +457,9 @@ func NewRepositoryMock(t minimock.Tester) *RepositoryMock {
 	m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock = mRepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissions{mock: m}
 	m.GetPaginatedComponentRunsByPipelineRunIDWithPermissionsMock.callArgs = []*RepositoryMockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsParams{}
 
+	m.GetPaginatedPipelineRunsByCreditOwnerMock = mRepositoryMockGetPaginatedPipelineRunsByCreditOwner{mock: m}
+	m.GetPaginatedPipelineRunsByCreditOwnerMock.callArgs = []*RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams{}
+
 	m.GetPaginatedPipelineRunsWithPermissionsMock = mRepositoryMockGetPaginatedPipelineRunsWithPermissions{mock: m}
 	m.GetPaginatedPipelineRunsWithPermissionsMock.callArgs = []*RepositoryMockGetPaginatedPipelineRunsWithPermissionsParams{}
 
@@ -8474,6 +8488,536 @@ func (m *RepositoryMock) MinimockGetPaginatedComponentRunsByPipelineRunIDWithPer
 	}
 }
 
+type mRepositoryMockGetPaginatedPipelineRunsByCreditOwner struct {
+	optional           bool
+	mock               *RepositoryMock
+	defaultExpectation *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation
+	expectations       []*RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation
+
+	callArgs []*RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams
+	mutex    sync.RWMutex
+
+	expectedInvocations       uint64
+	expectedInvocationsOrigin string
+}
+
+// RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation specifies expectation struct of the Repository.GetPaginatedPipelineRunsByCreditOwner
+type RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation struct {
+	mock               *RepositoryMock
+	params             *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams
+	paramPtrs          *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs
+	expectationOrigins RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectationOrigins
+	results            *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerResults
+	returnOrigin       string
+	Counter            uint64
+}
+
+// RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams contains parameters of the Repository.GetPaginatedPipelineRunsByCreditOwner
+type RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams struct {
+	ctx          context.Context
+	requesterUID string
+	startTime    time.Time
+	endTime      time.Time
+	page         int
+	pageSize     int
+	filter       filtering.Filter
+	order        ordering.OrderBy
+}
+
+// RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs contains pointers to parameters of the Repository.GetPaginatedPipelineRunsByCreditOwner
+type RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs struct {
+	ctx          *context.Context
+	requesterUID *string
+	startTime    *time.Time
+	endTime      *time.Time
+	page         *int
+	pageSize     *int
+	filter       *filtering.Filter
+	order        *ordering.OrderBy
+}
+
+// RepositoryMockGetPaginatedPipelineRunsByCreditOwnerResults contains results of the Repository.GetPaginatedPipelineRunsByCreditOwner
+type RepositoryMockGetPaginatedPipelineRunsByCreditOwnerResults struct {
+	pa1 []datamodel.PipelineRun
+	i1  int64
+	err error
+}
+
+// RepositoryMockGetPaginatedPipelineRunsByCreditOwnerOrigins contains origins of expectations of the Repository.GetPaginatedPipelineRunsByCreditOwner
+type RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectationOrigins struct {
+	origin             string
+	originCtx          string
+	originRequesterUID string
+	originStartTime    string
+	originEndTime      string
+	originPage         string
+	originPageSize     string
+	originFilter       string
+	originOrder        string
+}
+
+// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
+// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
+// Optional() makes method check to work in '0 or more' mode.
+// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
+// catch the problems when the expected method call is totally skipped during test run.
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Optional() *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	mmGetPaginatedPipelineRunsByCreditOwner.optional = true
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// Expect sets up expected params for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Expect(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by ExpectParams functions")
+	}
+
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams{ctx, requesterUID, startTime, endTime, page, pageSize, filter, order}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
+	for _, e := range mmGetPaginatedPipelineRunsByCreditOwner.expectations {
+		if minimock.Equal(e.params, mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params) {
+			mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params)
+		}
+	}
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectCtxParam1 sets up expected param ctx for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectCtxParam1(ctx context.Context) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.ctx = &ctx
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectRequesterUIDParam2 sets up expected param requesterUID for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectRequesterUIDParam2(requesterUID string) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.requesterUID = &requesterUID
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originRequesterUID = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectStartTimeParam3 sets up expected param startTime for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectStartTimeParam3(startTime time.Time) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.startTime = &startTime
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originStartTime = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectEndTimeParam4 sets up expected param endTime for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectEndTimeParam4(endTime time.Time) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.endTime = &endTime
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originEndTime = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectPageParam5 sets up expected param page for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectPageParam5(page int) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.page = &page
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originPage = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectPageSizeParam6 sets up expected param pageSize for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectPageSizeParam6(pageSize int) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.pageSize = &pageSize
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originPageSize = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectFilterParam7 sets up expected param filter for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectFilterParam7(filter filtering.Filter) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.filter = &filter
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originFilter = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// ExpectOrderParam8 sets up expected param order for Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) ExpectOrderParam8(order ordering.OrderBy) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.params != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Expect")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParamPtrs{}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.paramPtrs.order = &order
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.expectationOrigins.originOrder = minimock.CallerInfo(1)
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// Inspect accepts an inspector function that has same arguments as the Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Inspect(f func(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy)) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.inspectFuncGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("Inspect function is already set for RepositoryMock.GetPaginatedPipelineRunsByCreditOwner")
+	}
+
+	mmGetPaginatedPipelineRunsByCreditOwner.mock.inspectFuncGetPaginatedPipelineRunsByCreditOwner = f
+
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+// Return sets up results that will be returned by Repository.GetPaginatedPipelineRunsByCreditOwner
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Return(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{mock: mmGetPaginatedPipelineRunsByCreditOwner.mock}
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.results = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerResults{pa1, i1, err}
+	mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
+	return mmGetPaginatedPipelineRunsByCreditOwner.mock
+}
+
+// Set uses given function f to mock the Repository.GetPaginatedPipelineRunsByCreditOwner method
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Set(f func(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (pa1 []datamodel.PipelineRun, i1 int64, err error)) *RepositoryMock {
+	if mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("Default expectation is already set for the Repository.GetPaginatedPipelineRunsByCreditOwner method")
+	}
+
+	if len(mmGetPaginatedPipelineRunsByCreditOwner.expectations) > 0 {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("Some expectations are already set for the Repository.GetPaginatedPipelineRunsByCreditOwner method")
+	}
+
+	mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner = f
+	mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwnerOrigin = minimock.CallerInfo(1)
+	return mmGetPaginatedPipelineRunsByCreditOwner.mock
+}
+
+// When sets expectation for the Repository.GetPaginatedPipelineRunsByCreditOwner which will trigger the result defined by the following
+// Then helper
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) When(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation {
+	if mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock is already set by Set")
+	}
+
+	expectation := &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation{
+		mock:               mmGetPaginatedPipelineRunsByCreditOwner.mock,
+		params:             &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams{ctx, requesterUID, startTime, endTime, page, pageSize, filter, order},
+		expectationOrigins: RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectationOrigins{origin: minimock.CallerInfo(1)},
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.expectations = append(mmGetPaginatedPipelineRunsByCreditOwner.expectations, expectation)
+	return expectation
+}
+
+// Then sets up Repository.GetPaginatedPipelineRunsByCreditOwner return parameters for the expectation previously defined by the When method
+func (e *RepositoryMockGetPaginatedPipelineRunsByCreditOwnerExpectation) Then(pa1 []datamodel.PipelineRun, i1 int64, err error) *RepositoryMock {
+	e.results = &RepositoryMockGetPaginatedPipelineRunsByCreditOwnerResults{pa1, i1, err}
+	return e.mock
+}
+
+// Times sets number of times Repository.GetPaginatedPipelineRunsByCreditOwner should be invoked
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Times(n uint64) *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner {
+	if n == 0 {
+		mmGetPaginatedPipelineRunsByCreditOwner.mock.t.Fatalf("Times of RepositoryMock.GetPaginatedPipelineRunsByCreditOwner mock can not be zero")
+	}
+	mm_atomic.StoreUint64(&mmGetPaginatedPipelineRunsByCreditOwner.expectedInvocations, n)
+	mmGetPaginatedPipelineRunsByCreditOwner.expectedInvocationsOrigin = minimock.CallerInfo(1)
+	return mmGetPaginatedPipelineRunsByCreditOwner
+}
+
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) invocationsDone() bool {
+	if len(mmGetPaginatedPipelineRunsByCreditOwner.expectations) == 0 && mmGetPaginatedPipelineRunsByCreditOwner.defaultExpectation == nil && mmGetPaginatedPipelineRunsByCreditOwner.mock.funcGetPaginatedPipelineRunsByCreditOwner == nil {
+		return true
+	}
+
+	totalInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByCreditOwner.mock.afterGetPaginatedPipelineRunsByCreditOwnerCounter)
+	expectedInvocations := mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByCreditOwner.expectedInvocations)
+
+	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
+}
+
+// GetPaginatedPipelineRunsByCreditOwner implements mm_repository.Repository
+func (mmGetPaginatedPipelineRunsByCreditOwner *RepositoryMock) GetPaginatedPipelineRunsByCreditOwner(ctx context.Context, requesterUID string, startTime time.Time, endTime time.Time, page int, pageSize int, filter filtering.Filter, order ordering.OrderBy) (pa1 []datamodel.PipelineRun, i1 int64, err error) {
+	mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByCreditOwner.beforeGetPaginatedPipelineRunsByCreditOwnerCounter, 1)
+	defer mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByCreditOwner.afterGetPaginatedPipelineRunsByCreditOwnerCounter, 1)
+
+	mmGetPaginatedPipelineRunsByCreditOwner.t.Helper()
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.inspectFuncGetPaginatedPipelineRunsByCreditOwner != nil {
+		mmGetPaginatedPipelineRunsByCreditOwner.inspectFuncGetPaginatedPipelineRunsByCreditOwner(ctx, requesterUID, startTime, endTime, page, pageSize, filter, order)
+	}
+
+	mm_params := RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams{ctx, requesterUID, startTime, endTime, page, pageSize, filter, order}
+
+	// Record call args
+	mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.mutex.Lock()
+	mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.callArgs = append(mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.callArgs, &mm_params)
+	mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.mutex.Unlock()
+
+	for _, e := range mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.expectations {
+		if minimock.Equal(*e.params, mm_params) {
+			mm_atomic.AddUint64(&e.Counter, 1)
+			return e.results.pa1, e.results.i1, e.results.err
+		}
+	}
+
+	if mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation != nil {
+		mm_atomic.AddUint64(&mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.Counter, 1)
+		mm_want := mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.params
+		mm_want_ptrs := mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.paramPtrs
+
+		mm_got := RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams{ctx, requesterUID, startTime, endTime, page, pageSize, filter, order}
+
+		if mm_want_ptrs != nil {
+
+			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
+			}
+
+			if mm_want_ptrs.requesterUID != nil && !minimock.Equal(*mm_want_ptrs.requesterUID, mm_got.requesterUID) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter requesterUID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originRequesterUID, *mm_want_ptrs.requesterUID, mm_got.requesterUID, minimock.Diff(*mm_want_ptrs.requesterUID, mm_got.requesterUID))
+			}
+
+			if mm_want_ptrs.startTime != nil && !minimock.Equal(*mm_want_ptrs.startTime, mm_got.startTime) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter startTime, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originStartTime, *mm_want_ptrs.startTime, mm_got.startTime, minimock.Diff(*mm_want_ptrs.startTime, mm_got.startTime))
+			}
+
+			if mm_want_ptrs.endTime != nil && !minimock.Equal(*mm_want_ptrs.endTime, mm_got.endTime) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter endTime, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originEndTime, *mm_want_ptrs.endTime, mm_got.endTime, minimock.Diff(*mm_want_ptrs.endTime, mm_got.endTime))
+			}
+
+			if mm_want_ptrs.page != nil && !minimock.Equal(*mm_want_ptrs.page, mm_got.page) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter page, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originPage, *mm_want_ptrs.page, mm_got.page, minimock.Diff(*mm_want_ptrs.page, mm_got.page))
+			}
+
+			if mm_want_ptrs.pageSize != nil && !minimock.Equal(*mm_want_ptrs.pageSize, mm_got.pageSize) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter pageSize, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originPageSize, *mm_want_ptrs.pageSize, mm_got.pageSize, minimock.Diff(*mm_want_ptrs.pageSize, mm_got.pageSize))
+			}
+
+			if mm_want_ptrs.filter != nil && !minimock.Equal(*mm_want_ptrs.filter, mm_got.filter) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter filter, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originFilter, *mm_want_ptrs.filter, mm_got.filter, minimock.Diff(*mm_want_ptrs.filter, mm_got.filter))
+			}
+
+			if mm_want_ptrs.order != nil && !minimock.Equal(*mm_want_ptrs.order, mm_got.order) {
+				mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameter order, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.originOrder, *mm_want_ptrs.order, mm_got.order, minimock.Diff(*mm_want_ptrs.order, mm_got.order))
+			}
+
+		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
+			mmGetPaginatedPipelineRunsByCreditOwner.t.Errorf("RepositoryMock.GetPaginatedPipelineRunsByCreditOwner got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+				mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
+		}
+
+		mm_results := mmGetPaginatedPipelineRunsByCreditOwner.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.results
+		if mm_results == nil {
+			mmGetPaginatedPipelineRunsByCreditOwner.t.Fatal("No results are set for the RepositoryMock.GetPaginatedPipelineRunsByCreditOwner")
+		}
+		return (*mm_results).pa1, (*mm_results).i1, (*mm_results).err
+	}
+	if mmGetPaginatedPipelineRunsByCreditOwner.funcGetPaginatedPipelineRunsByCreditOwner != nil {
+		return mmGetPaginatedPipelineRunsByCreditOwner.funcGetPaginatedPipelineRunsByCreditOwner(ctx, requesterUID, startTime, endTime, page, pageSize, filter, order)
+	}
+	mmGetPaginatedPipelineRunsByCreditOwner.t.Fatalf("Unexpected call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner. %v %v %v %v %v %v %v %v", ctx, requesterUID, startTime, endTime, page, pageSize, filter, order)
+	return
+}
+
+// GetPaginatedPipelineRunsByCreditOwnerAfterCounter returns a count of finished RepositoryMock.GetPaginatedPipelineRunsByCreditOwner invocations
+func (mmGetPaginatedPipelineRunsByCreditOwner *RepositoryMock) GetPaginatedPipelineRunsByCreditOwnerAfterCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByCreditOwner.afterGetPaginatedPipelineRunsByCreditOwnerCounter)
+}
+
+// GetPaginatedPipelineRunsByCreditOwnerBeforeCounter returns a count of RepositoryMock.GetPaginatedPipelineRunsByCreditOwner invocations
+func (mmGetPaginatedPipelineRunsByCreditOwner *RepositoryMock) GetPaginatedPipelineRunsByCreditOwnerBeforeCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGetPaginatedPipelineRunsByCreditOwner.beforeGetPaginatedPipelineRunsByCreditOwnerCounter)
+}
+
+// Calls returns a list of arguments used in each call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner.
+// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
+func (mmGetPaginatedPipelineRunsByCreditOwner *mRepositoryMockGetPaginatedPipelineRunsByCreditOwner) Calls() []*RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams {
+	mmGetPaginatedPipelineRunsByCreditOwner.mutex.RLock()
+
+	argCopy := make([]*RepositoryMockGetPaginatedPipelineRunsByCreditOwnerParams, len(mmGetPaginatedPipelineRunsByCreditOwner.callArgs))
+	copy(argCopy, mmGetPaginatedPipelineRunsByCreditOwner.callArgs)
+
+	mmGetPaginatedPipelineRunsByCreditOwner.mutex.RUnlock()
+
+	return argCopy
+}
+
+// MinimockGetPaginatedPipelineRunsByCreditOwnerDone returns true if the count of the GetPaginatedPipelineRunsByCreditOwner invocations corresponds
+// the number of defined expectations
+func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByCreditOwnerDone() bool {
+	if m.GetPaginatedPipelineRunsByCreditOwnerMock.optional {
+		// Optional methods provide '0 or more' call count restriction.
+		return true
+	}
+
+	for _, e := range m.GetPaginatedPipelineRunsByCreditOwnerMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			return false
+		}
+	}
+
+	return m.GetPaginatedPipelineRunsByCreditOwnerMock.invocationsDone()
+}
+
+// MinimockGetPaginatedPipelineRunsByCreditOwnerInspect logs each unmet expectation
+func (m *RepositoryMock) MinimockGetPaginatedPipelineRunsByCreditOwnerInspect() {
+	for _, e := range m.GetPaginatedPipelineRunsByCreditOwnerMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
+		}
+	}
+
+	afterGetPaginatedPipelineRunsByCreditOwnerCounter := mm_atomic.LoadUint64(&m.afterGetPaginatedPipelineRunsByCreditOwnerCounter)
+	// if default expectation was set then invocations count should be greater than zero
+	if m.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation != nil && afterGetPaginatedPipelineRunsByCreditOwnerCounter < 1 {
+		if m.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.params == nil {
+			m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner at\n%s", m.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.returnOrigin)
+		} else {
+			m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner at\n%s with params: %#v", m.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.expectationOrigins.origin, *m.GetPaginatedPipelineRunsByCreditOwnerMock.defaultExpectation.params)
+		}
+	}
+	// if func was set then invocations count should be greater than zero
+	if m.funcGetPaginatedPipelineRunsByCreditOwner != nil && afterGetPaginatedPipelineRunsByCreditOwnerCounter < 1 {
+		m.t.Errorf("Expected call to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner at\n%s", m.funcGetPaginatedPipelineRunsByCreditOwnerOrigin)
+	}
+
+	if !m.GetPaginatedPipelineRunsByCreditOwnerMock.invocationsDone() && afterGetPaginatedPipelineRunsByCreditOwnerCounter > 0 {
+		m.t.Errorf("Expected %d calls to RepositoryMock.GetPaginatedPipelineRunsByCreditOwner at\n%s but found %d calls",
+			mm_atomic.LoadUint64(&m.GetPaginatedPipelineRunsByCreditOwnerMock.expectedInvocations), m.GetPaginatedPipelineRunsByCreditOwnerMock.expectedInvocationsOrigin, afterGetPaginatedPipelineRunsByCreditOwnerCounter)
+	}
+}
+
 type mRepositoryMockGetPaginatedPipelineRunsWithPermissions struct {
 	optional           bool
 	mock               *RepositoryMock
@@ -20206,6 +20750,8 @@ func (m *RepositoryMock) MinimockFinish() {
 
 			m.MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsInspect()
 
+			m.MinimockGetPaginatedPipelineRunsByCreditOwnerInspect()
+
 			m.MinimockGetPaginatedPipelineRunsWithPermissionsInspect()
 
 			m.MinimockGetPipelineByIDAdminInspect()
@@ -20307,6 +20853,7 @@ func (m *RepositoryMock) minimockDone() bool {
 		m.MinimockGetNamespacePipelineReleaseByIDDone() &&
 		m.MinimockGetNamespaceSecretByIDDone() &&
 		m.MinimockGetPaginatedComponentRunsByPipelineRunIDWithPermissionsDone() &&
+		m.MinimockGetPaginatedPipelineRunsByCreditOwnerDone() &&
 		m.MinimockGetPaginatedPipelineRunsWithPermissionsDone() &&
 		m.MinimockGetPipelineByIDAdminDone() &&
 		m.MinimockGetPipelineByUIDDone() &&
diff --git a/pkg/repository/repository.go b/pkg/repository/repository.go
index e659fcf67..39b08169a 100644
--- a/pkg/repository/repository.go
+++ b/pkg/repository/repository.go
@@ -106,6 +106,7 @@ type Repository interface {
 
 	GetPaginatedPipelineRunsWithPermissions(ctx context.Context, requesterUID, pipelineUID string, page, pageSize int, filter filtering.Filter, order ordering.OrderBy, isOwner bool) ([]datamodel.PipelineRun, int64, error)
 	GetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx context.Context, pipelineRunID string, page, pageSize int, filter filtering.Filter, order ordering.OrderBy) ([]datamodel.ComponentRun, int64, error)
+	GetPaginatedPipelineRunsByCreditOwner(ctx context.Context, requesterUID string, startTime, endTime time.Time, page, pageSize int, filter filtering.Filter, order ordering.OrderBy) ([]datamodel.PipelineRun, int64, error)
 }
 
 type repository struct {
@@ -1130,7 +1131,7 @@ func (r *repository) AddPipelineClones(ctx context.Context, pipelineUID uuid.UUI
 
 func (r *repository) GetPipelineRunByUID(ctx context.Context, pipelineTriggerUID uuid.UUID) (*datamodel.PipelineRun, error) {
 	pipelineRun := &datamodel.PipelineRun{PipelineTriggerUID: pipelineTriggerUID}
-	err := r.db.First(pipelineRun).Error
+	err := r.db.Preload(clause.Associations).First(pipelineRun).Error
 	if err != nil {
 		return nil, err
 	}
@@ -1271,6 +1272,60 @@ func (r *repository) GetPaginatedComponentRunsByPipelineRunIDWithPermissions(ctx
 	return componentRuns, totalRows, nil
 }
 
+func (r *repository) GetPaginatedPipelineRunsByCreditOwner(ctx context.Context, requesterUID string, startTimeBegin, startTimeEnd time.Time, page, pageSize int, filter filtering.Filter, order ordering.OrderBy) ([]datamodel.PipelineRun, int64, error) {
+	var pipelineRuns []datamodel.PipelineRun
+	var totalRows int64
+
+	whereConditions := []string{"namespace = ? and started_time >= ? and started_time <= ?"}
+	whereArgs := []any{requesterUID, startTimeBegin, startTimeEnd}
+
+	var expr *clause.Expr
+	var err error
+	if expr, err = r.TranspileFilter(filter); err != nil {
+		return nil, 0, err
+	}
+	if expr != nil {
+		whereConditions = append(whereConditions, "(?)")
+		whereArgs = append(whereArgs, expr)
+	}
+
+	var where string
+	if len(whereConditions) > 0 {
+		where = strings.Join(whereConditions, " and ")
+	}
+
+	err = r.db.Model(&datamodel.PipelineRun{}).
+		Where(where, whereArgs...).
+		Count(&totalRows).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	queryBuilder := r.db.Preload(clause.Associations).Where(where, whereArgs...)
+
+	if len(order.Fields) == 0 {
+		order.Fields = append(order.Fields, ordering.Field{
+			Path: "started_time",
+			Desc: true,
+		})
+	}
+
+	for _, field := range order.Fields {
+		orderString := strcase.ToSnake(field.Path) + transformBoolToDescString(field.Desc)
+		queryBuilder.Order(orderString)
+	}
+
+	// Retrieve paginated results with permissions
+	err = queryBuilder.
+		Offset(page * pageSize).Limit(pageSize).
+		Find(&pipelineRuns).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return pipelineRuns, totalRows, nil
+}
+
 func (r *repository) CreateNamespaceConnection(ctx context.Context, conn *datamodel.Connection) (*datamodel.Connection, error) {
 	db := r.db.WithContext(ctx)
 
diff --git a/pkg/repository/repository_test.go b/pkg/repository/repository_test.go
index 1da610a46..ed0cd588c 100644
--- a/pkg/repository/repository_test.go
+++ b/pkg/repository/repository_test.go
@@ -16,6 +16,7 @@ import (
 	"github.com/go-redis/redismock/v9"
 	"github.com/gofrs/uuid"
 	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/stretchr/testify/require"
 	"go.einride.tech/aip/filtering"
 	"go.einride.tech/aip/ordering"
 	"go.uber.org/zap"
@@ -32,6 +33,7 @@ import (
 	componentstore "github.com/instill-ai/pipeline-backend/pkg/component/store"
 	database "github.com/instill-ai/pipeline-backend/pkg/db"
 	errdomain "github.com/instill-ai/pipeline-backend/pkg/errors"
+
 	runpb "github.com/instill-ai/protogen-go/common/run/v1alpha"
 	pipelinepb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
@@ -480,6 +482,7 @@ func TestRepository_UpsertPipelineRun(t *testing.T) {
 	c.Check(got1.PipelineUID, qt.Equals, p.UID)
 	c.Check(got1.Status, qt.Equals, pipelineRun.Status)
 	c.Check(got1.Source, qt.Equals, pipelineRun.Source)
+	c.Check(got1.Pipeline.UID, qt.Equals, p.UID)
 
 	componentRun := &datamodel.ComponentRun{
 		PipelineTriggerUID: pipelineRun.PipelineTriggerUID,
@@ -611,10 +614,121 @@ func TestRepository_GetPaginatedPipelineRunsWithPermissions(t *testing.T) {
 			c.Assert(err, qt.IsNil)
 			if testCase.canView {
 				c.Check(len(response), qt.Equals, 1)
+				// c.Log(response[0].Pipeline.ID)
+				// c.Check(response[0].Pipeline.ID, qt.Equals, p.ID)
 			} else {
 				c.Check(len(response), qt.Equals, 0)
 			}
 		})
 	}
+}
+
+func TestRepository_GetPaginatedPipelineRunsByCreditOwner(t *testing.T) {
+	c := qt.New(t)
+	ctx := context.Background()
+
+	cache, _ := redismock.NewClientMock()
+
+	t0 := time.Now().UTC()
+
+	mockUIDs := make([]uuid.UUID, 5)
+	for i := range len(mockUIDs) {
+		mockUIDs[i] = uuid.Must(uuid.NewV4())
+	}
+	user1 := mockUIDs[0].String()
+	namespace1 := mockUIDs[1].String()
+	now := time.Now()
+
+	pipelineUID, ownerUID := mockUIDs[2], mockUIDs[3]
+	pipelineUID2 := mockUIDs[4]
+	ownerPermalink := "users/" + ownerUID.String()
+	pipelineID := "test"
+	pipelineID2 := "test2"
+
+	tx := db.Begin()
+	c.Cleanup(func() { tx.Rollback() })
+
+	repo := NewRepository(tx, cache)
+
+	p := &datamodel.Pipeline{
+		Owner: ownerPermalink,
+		ID:    pipelineID,
+		BaseDynamic: datamodel.BaseDynamic{
+			UID:        pipelineUID,
+			CreateTime: t0,
+			UpdateTime: t0,
+		},
+	}
+	err := repo.CreateNamespacePipeline(ctx, p)
+	require.NoError(t, err)
+
+	p2 := &datamodel.Pipeline{
+		Owner: ownerPermalink,
+		ID:    pipelineID2,
+		BaseDynamic: datamodel.BaseDynamic{
+			UID:        pipelineUID2,
+			CreateTime: t0,
+			UpdateTime: t0,
+		},
+	}
+	err = repo.CreateNamespacePipeline(ctx, p2)
+	require.NoError(t, err)
+
+	got, err := repo.GetNamespacePipelineByID(ctx, ownerPermalink, pipelineID, true, false)
+	require.NoError(t, err)
+	require.Zero(t, got.NumberOfRuns)
+	require.True(t, got.LastRunTime.IsZero())
+
+	got, err = repo.GetNamespacePipelineByID(ctx, ownerPermalink, pipelineID2, true, false)
+	require.NoError(t, err)
+	require.Zero(t, got.NumberOfRuns)
+	require.True(t, got.LastRunTime.IsZero())
+
+	pipelineRun := &datamodel.PipelineRun{
+		PipelineTriggerUID: uuid.Must(uuid.NewV4()),
+		PipelineUID:        p.UID,
+		Status:             datamodel.RunStatus(runpb.RunStatus_RUN_STATUS_PROCESSING),
+		Source:             datamodel.RunSource(runpb.RunSource_RUN_SOURCE_API),
+		TriggeredBy:        user1,
+		Namespace:          namespace1,
+		StartedTime:        now.Add(-1 * time.Hour),
+		TotalDuration:      null.IntFrom(42),
+		Components:         nil,
+	}
+
+	err = repo.UpsertPipelineRun(ctx, pipelineRun)
+	require.NoError(t, err)
+
+	resp, _, err := repo.GetPaginatedPipelineRunsByCreditOwner(ctx, namespace1, now.Add(-3*time.Hour), now.Add(-2*time.Hour), 0, 10, filtering.Filter{}, ordering.OrderBy{})
+	require.NoError(t, err)
+	require.Len(t, resp, 0)
+
+	resp, _, err = repo.GetPaginatedPipelineRunsByCreditOwner(ctx, namespace1, now.Add(-2*time.Hour), now, 0, 10, filtering.Filter{}, ordering.OrderBy{})
+	require.NoError(t, err)
+	require.Len(t, resp, 1)
+	require.Equal(t, resp[0].PipelineTriggerUID, pipelineRun.PipelineTriggerUID)
+	require.Equal(t, resp[0].Pipeline.ID, p.ID)
+
+	pipelineRun2 := &datamodel.PipelineRun{
+		PipelineTriggerUID: uuid.Must(uuid.NewV4()),
+		PipelineUID:        p2.UID,
+		Status:             datamodel.RunStatus(runpb.RunStatus_RUN_STATUS_PROCESSING),
+		Source:             datamodel.RunSource(runpb.RunSource_RUN_SOURCE_API),
+		TriggeredBy:        user1,
+		Namespace:          namespace1,
+		StartedTime:        now.Add(-1 * time.Hour),
+		TotalDuration:      null.IntFrom(42),
+		Components:         nil,
+	}
+
+	err = repo.UpsertPipelineRun(ctx, pipelineRun2)
+	require.NoError(t, err)
 
+	resp, _, err = repo.GetPaginatedPipelineRunsByCreditOwner(ctx, namespace1, now.Add(-2*time.Hour), now, 0, 10, filtering.Filter{}, ordering.OrderBy{})
+	require.NoError(t, err)
+	require.Len(t, resp, 2)
+	require.Equal(t, resp[0].PipelineTriggerUID, pipelineRun.PipelineTriggerUID)
+	require.Equal(t, resp[0].Pipeline.ID, p.ID)
+	require.Equal(t, resp[1].PipelineTriggerUID, pipelineRun2.PipelineTriggerUID)
+	require.Equal(t, resp[1].Pipeline.ID, p2.ID)
 }
diff --git a/pkg/service/component_definition.go b/pkg/service/component_definition.go
index c9346d3e5..3d1af6e64 100644
--- a/pkg/service/component_definition.go
+++ b/pkg/service/component_definition.go
@@ -13,10 +13,12 @@ import (
 
 	"github.com/instill-ai/pipeline-backend/pkg/recipe"
 	"github.com/instill-ai/pipeline-backend/pkg/repository"
-	"github.com/instill-ai/x/paginate"
 
 	component "github.com/instill-ai/pipeline-backend/pkg/component/store"
 	errdomain "github.com/instill-ai/pipeline-backend/pkg/errors"
+
+	"github.com/instill-ai/x/paginate"
+
 	pb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
 
diff --git a/pkg/service/convert.go b/pkg/service/convert.go
index 023a3840a..6323fa020 100644
--- a/pkg/service/convert.go
+++ b/pkg/service/convert.go
@@ -42,6 +42,7 @@ import (
 	componentbase "github.com/instill-ai/pipeline-backend/pkg/component/base"
 	componentstore "github.com/instill-ai/pipeline-backend/pkg/component/store"
 	errdomain "github.com/instill-ai/pipeline-backend/pkg/errors"
+
 	mgmtpb "github.com/instill-ai/protogen-go/core/mgmt/v1beta"
 	pb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
diff --git a/pkg/service/main.go b/pkg/service/main.go
index 7dcfe29a7..913d4659f 100644
--- a/pkg/service/main.go
+++ b/pkg/service/main.go
@@ -20,6 +20,7 @@ import (
 	"github.com/instill-ai/pipeline-backend/pkg/resource"
 
 	componentstore "github.com/instill-ai/pipeline-backend/pkg/component/store"
+
 	mgmtpb "github.com/instill-ai/protogen-go/core/mgmt/v1beta"
 	pb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
@@ -78,6 +79,7 @@ type Service interface {
 
 	ListPipelineRuns(ctx context.Context, req *pb.ListPipelineRunsRequest, filter filtering.Filter) (*pb.ListPipelineRunsResponse, error)
 	ListComponentRuns(ctx context.Context, req *pb.ListComponentRunsRequest, filter filtering.Filter) (*pb.ListComponentRunsResponse, error)
+	ListPipelineRunsByCreditOwner(ctx context.Context, req *pb.ListPipelineRunsByCreditOwnerRequest, filter filtering.Filter) (*pb.ListPipelineRunsByCreditOwnerResponse, error)
 
 	GetIntegration(_ context.Context, id string, _ pb.View) (*pb.Integration, error)
 	ListIntegrations(context.Context, *pb.ListIntegrationsRequest) (*pb.ListIntegrationsResponse, error)
diff --git a/pkg/service/pipeline.go b/pkg/service/pipeline.go
index 737516f28..952821a89 100644
--- a/pkg/service/pipeline.go
+++ b/pkg/service/pipeline.go
@@ -40,11 +40,11 @@ import (
 	"github.com/instill-ai/pipeline-backend/pkg/utils"
 	"github.com/instill-ai/pipeline-backend/pkg/worker"
 
+	componentbase "github.com/instill-ai/pipeline-backend/pkg/component/base"
 	errdomain "github.com/instill-ai/pipeline-backend/pkg/errors"
 
 	"github.com/instill-ai/x/errmsg"
 
-	componentbase "github.com/instill-ai/pipeline-backend/pkg/component/base"
 	mgmtpb "github.com/instill-ai/protogen-go/core/mgmt/v1beta"
 	pipelinepb "github.com/instill-ai/protogen-go/vdp/pipeline/v1beta"
 )
@@ -1988,3 +1988,52 @@ func (s *service) ListComponentRuns(ctx context.Context, req *pipelinepb.ListCom
 		PageSize:      int32(pageSize),
 	}, nil
 }
+
+func (s *service) ListPipelineRunsByCreditOwner(ctx context.Context, req *pipelinepb.ListPipelineRunsByCreditOwnerRequest,
+	filter filtering.Filter) (*pipelinepb.ListPipelineRunsByCreditOwnerResponse, error) {
+	page := s.pageInRange(req.GetPage())
+	pageSize := s.pageSizeInRange(req.GetPageSize())
+	requesterUID, _ := utils.GetRequesterUIDAndUserUID(ctx)
+
+	log, _ := logger.GetZapLogger(ctx)
+
+	orderBy, err := ordering.ParseOrderBy(req)
+	if err != nil {
+		return nil, err
+	}
+
+	now := time.Now().UTC()
+	startedTimeBegin := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+	if req.GetStart().IsValid() {
+		startedTimeBegin = req.GetStart().AsTime()
+	}
+	startedTimeEnd := now
+	if req.GetStop().IsValid() {
+		startedTimeEnd = req.GetStop().AsTime()
+	}
+	log.Info("ListPipelineRunsByCreditOwner", zap.Time("startedTimeBegin", startedTimeBegin), zap.Time("startedTimeEnd", startedTimeEnd))
+
+	pipelineRuns, totalCount, err := s.repository.GetPaginatedPipelineRunsByCreditOwner(ctx, requesterUID, startedTimeBegin, startedTimeEnd,
+		page, pageSize, filter, orderBy)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get pipeline runs: %w", err)
+	}
+
+	pbPipelineRuns := make([]*pipelinepb.PipelineRun, len(pipelineRuns))
+
+	var pbRun *pipelinepb.PipelineRun
+	for i, run := range pipelineRuns {
+		pbRun, err = s.convertPipelineRunToPB(run)
+		if err != nil {
+			return nil, fmt.Errorf("failed to convert pipeline run: %w", err)
+		}
+		pbPipelineRuns[i] = pbRun
+	}
+
+	return &pipelinepb.ListPipelineRunsByCreditOwnerResponse{
+		PipelineRuns: pbPipelineRuns,
+		TotalSize:    totalCount,
+		Page:         int32(page),
+		PageSize:     int32(pageSize),
+	}, nil
+}
diff --git a/pkg/service/pipeline_repository_test.go b/pkg/service/pipeline_repository_test.go
index a2f64b866..fa874480f 100644
--- a/pkg/service/pipeline_repository_test.go
+++ b/pkg/service/pipeline_repository_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	qt "github.com/frankban/quicktest"
 	"github.com/go-redis/redismock/v9"
 	"github.com/gofrs/uuid"
 	"github.com/gojuno/minimock/v3"
@@ -20,6 +19,8 @@ import (
 	"gopkg.in/guregu/null.v4"
 	"gorm.io/gorm"
 
+	qt "github.com/frankban/quicktest"
+
 	"github.com/instill-ai/pipeline-backend/config"
 	"github.com/instill-ai/pipeline-backend/pkg/constant"
 	"github.com/instill-ai/pipeline-backend/pkg/datamodel"
@@ -189,7 +190,7 @@ func TestService_ListPipelineRuns(t *testing.T) {
 				aclClient,
 				mockConverter,
 				mgmtPrivateClient,
-				mockMinio,
+				mockMinio, nil, nil, uuid.Must(uuid.NewV4()),
 			)
 
 			ctx := context.Background()
@@ -410,7 +411,7 @@ func TestService_ListPipelineRuns_OrgResource(t *testing.T) {
 				aclClient,
 				mockConverter,
 				mgmtPrivateClient,
-				mockMinio,
+				mockMinio, nil, nil, uuid.Must(uuid.NewV4()),
 			)
 
 			ctx := context.Background()
diff --git a/pkg/service/utils.go b/pkg/service/utils.go
index 844c76981..353269ca3 100644
--- a/pkg/service/utils.go
+++ b/pkg/service/utils.go
@@ -100,6 +100,7 @@ func (s *service) GetRscNamespace(ctx context.Context, namespaceID string) (reso
 func (s *service) convertPipelineRunToPB(run datamodel.PipelineRun) (*pipelinepb.PipelineRun, error) {
 	result := &pipelinepb.PipelineRun{
 		PipelineUid:     run.PipelineUID.String(),
+		PipelineId:      &run.Pipeline.ID,
 		PipelineRunUid:  run.PipelineTriggerUID.String(),
 		PipelineVersion: run.PipelineVersion,
 		Status:          runpb.RunStatus(run.Status),