diff --git a/core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java b/core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java
index 6bda016f18..f60b34dc9d 100644
--- a/core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java
+++ b/core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java
@@ -2,7 +2,6 @@ package io.kestra.core.repositories;
 
 import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.executions.Execution;
-import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.executions.statistics.DailyExecutionStatistics;
 import io.kestra.core.models.executions.statistics.ExecutionCount;
 import io.kestra.core.models.executions.statistics.Flow;
@@ -94,6 +93,8 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
 
     Flux<Execution> findAllAsync(@Nullable String tenantId);
 
+    Flux<Execution> findAsync(String tenantId, List<QueryFilter> filters);
+
     Execution delete(Execution execution);
 
     Integer purge(Execution execution);
diff --git a/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java b/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
index 692e4c881b..be3d53f008 100644
--- a/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
+++ b/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
@@ -8,6 +8,7 @@ import io.kestra.plugin.core.dashboard.data.Flows;
 import io.micronaut.data.model.Pageable;
 import jakarta.annotation.Nullable;
 import jakarta.validation.ConstraintViolationException;
+import reactor.core.publisher.Flux;
 
 import java.util.List;
 import java.util.Optional;
@@ -158,6 +159,8 @@ public interface FlowRepositoryInterface extends QueryBuilderInterface<Flows.Fie
             .toList();
     }
 
+    Flux<Flow> findAsync(String tenantId, List<QueryFilter> filters);
+
     FlowWithSource create(GenericFlow flow);
 
     FlowWithSource update(GenericFlow flow, FlowInterface previous) throws ConstraintViolationException;
diff --git a/core/src/main/java/io/kestra/core/repositories/TriggerRepositoryInterface.java b/core/src/main/java/io/kestra/core/repositories/TriggerRepositoryInterface.java
index 169fe47a0e..3c3fbb757a 100644
--- a/core/src/main/java/io/kestra/core/repositories/TriggerRepositoryInterface.java
+++ b/core/src/main/java/io/kestra/core/repositories/TriggerRepositoryInterface.java
@@ -43,9 +43,9 @@ public interface TriggerRepositoryInterface extends QueryBuilderInterface<Trigge
 
     /**
      * Find all triggers that match the query, return a flux of triggers
-     * as the search is not paginated
      */
-    Flux<Trigger> find(String tenantId, List<QueryFilter> filters);
+    Flux<Trigger> findAsync(String tenantId, List<QueryFilter> filters);
+
 
     default Function<String, String> sortMapping() throws IllegalArgumentException {
         return Function.identity();
diff --git a/core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java b/core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java
index 62b375bf8b..ed8edc57e8 100644
--- a/core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java
+++ b/core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java
@@ -840,4 +840,53 @@ inject(tenant);
         assertThat(byFlow.get(FLOW).getId()).isEqualTo(running.getId());
     }
 
+    @Test
+    void findAsync() {
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+
+        Execution execA = Execution.builder()
+            .id(IdUtils.create())
+            .tenantId(tenant)
+            .namespace(NAMESPACE)
+            .flowId("flowA")
+            .flowRevision(1)
+            .state(new State())
+            .taskRunList(List.of())
+            .build();
+
+        Execution execB = Execution.builder()
+            .id(IdUtils.create())
+            .tenantId(tenant)
+            .namespace(NAMESPACE)
+            .flowId("flowB")
+            .flowRevision(1)
+            .state(new State())
+            .taskRunList(List.of())
+            .build();
+
+        Execution savedA = executionRepository.save(execA);
+        Execution savedB = executionRepository.save(execB);
+
+        try {
+            List<Execution> all = executionRepository.findAllAsync(tenant).collectList().block();
+            assertThat(all).isNotNull();
+            assertThat(all.stream().map(Execution::getId).toList())
+                .containsExactlyInAnyOrder(savedA.getId(), savedB.getId());
+
+            // filtered using repository find (pageable) since findAllAsync has no filters
+            List<QueryFilter> filters = List.of(QueryFilter.builder()
+                .field(QueryFilter.Field.FLOW_ID)
+                .operation(QueryFilter.Op.EQUALS)
+                .value("flowA")
+                .build());
+
+            ArrayListTotal<Execution> filtered = executionRepository.find(Pageable.UNPAGED, tenant, filters);
+            assertThat(filtered.getTotal()).isEqualTo(1L);
+            assertThat(filtered.getFirst().getFlowId()).isEqualTo("flowA");
+        } finally {
+            executionRepository.delete(savedA);
+            executionRepository.delete(savedB);
+        }
+    }
+
 }
diff --git a/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java b/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
index 169bddcdc3..b9eca61329 100644
--- a/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
+++ b/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
@@ -29,7 +29,6 @@ import io.micronaut.data.model.Pageable;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import jakarta.validation.ConstraintViolationException;
-import java.util.concurrent.CopyOnWriteArrayList;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
 import org.junit.jupiter.api.BeforeAll;
@@ -41,15 +40,14 @@ import org.slf4j.event.Level;
 import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.SYSTEM;
 import static io.kestra.core.utils.NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 @KestraTest
 public abstract class AbstractFlowRepositoryTest {
@@ -683,6 +681,47 @@ public abstract class AbstractFlowRepositoryTest {
         }
     }
 
+    @Test
+    void findAsync() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+
+        FlowWithSource flowA = builder(tenant, "flowA", "taskA").build();
+        FlowWithSource flowB = builder(tenant, "flowB", "taskB").build();
+
+        FlowWithSource savedA = flowRepository.create(GenericFlow.of(flowA));
+        FlowWithSource savedB = flowRepository.create(GenericFlow.of(flowB));
+
+        try {
+            List<Flow> all = flowRepository.findAsync(tenant, null)
+                .collectList()
+                .block(Duration.ofSeconds(5));
+
+            assertThat(all).isNotNull();
+            assertThat(all.stream().map(Flow::getId).toList())
+                .containsExactlyInAnyOrder(savedA.getId(), savedB.getId());
+
+            // with a query filter targeting flowA -> only flowA
+            QueryFilter filter = QueryFilter.builder()
+                .field(Field.QUERY)
+                .value(savedA.getId())
+                .operation(Op.EQUALS)
+                .build();
+
+            List<Flow> filtered = flowRepository.findAsync(tenant, List.of(filter))
+                .collectList()
+                .block(Duration.ofSeconds(5));
+
+            assertThat(filtered).isNotNull();
+            assertThat(filtered).hasSize(1);
+            assertThat(filtered.getFirst().getId()).isEqualTo(savedA.getId());
+        } finally {
+            deleteFlow(savedA);
+            deleteFlow(savedB);
+        }
+    }
+
+
+
     private static Flow createTestFlowForNamespace(String tenantId, String namespace) {
         return Flow.builder()
             .id(IdUtils.create())
diff --git a/core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java b/core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java
index 807f078293..a8ec0a8e62 100644
--- a/core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java
+++ b/core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java
@@ -74,7 +74,7 @@ public abstract class AbstractTriggerRepositoryTest {
         String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         triggerRepository.save(generateDefaultTrigger(tenant));
 
-        List<Trigger> entries = triggerRepository.find(tenant, List.of(filter)).collectList().block();
+        List<Trigger> entries = triggerRepository.findAsync(tenant, List.of(filter)).collectList().block();
 
         assertThat(entries).hasSize(1);
     }
@@ -196,4 +196,35 @@ public abstract class AbstractTriggerRepositoryTest {
         // Then
         assertThat(count).isEqualTo(1);
     }
+
+    @Test
+    void findAsync() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+
+        Trigger.TriggerBuilder<?, ?> builderA = trigger(tenant).flowId("flowA").triggerId("tA");
+        Trigger.TriggerBuilder<?, ?> builderB = trigger(tenant).flowId("flowB").triggerId("tB");
+
+        Trigger savedA = triggerRepository.save(builderA.build());
+        Trigger savedB = triggerRepository.save(builderB.build());
+
+        try {
+            List<Trigger> all = triggerRepository.findAsync(tenant, null).collectList().block();
+            assertThat(all).isNotNull();
+            assertThat(all.stream().map(Trigger::getTriggerId).toList())
+                .containsExactlyInAnyOrder(savedA.getTriggerId(), savedB.getTriggerId());
+
+            List<QueryFilter> filters = List.of(QueryFilter.builder()
+                .field(QueryFilter.Field.FLOW_ID)
+                .operation(QueryFilter.Op.EQUALS)
+                .value("flowA")
+                .build());
+
+            List<Trigger> filtered = triggerRepository.findAsync(tenant, filters).collectList().block();
+            assertThat(filtered).hasSize(1);
+            assertThat(filtered.get(0).getFlowId()).isEqualTo("flowA");
+        } finally {
+            triggerRepository.delete(savedA);
+            triggerRepository.delete(savedB);
+        }
+    }
 }
diff --git a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcExecutionRepository.java b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcExecutionRepository.java
index 82a8159f2f..b7b965d81b 100644
--- a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcExecutionRepository.java
+++ b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcExecutionRepository.java
@@ -287,6 +287,15 @@ public abstract class AbstractJdbcExecutionRepository extends AbstractJdbcCrudRe
         return findPage(pageable, tenantId, condition);
     }
 
+    @Override
+    public Flux<Execution> findAsync(String tenantId, List<QueryFilter> filters) {
+        if (filters == null || filters.isEmpty()) {
+            return findAllAsync(tenantId);
+        }
+        Condition condition = this.filter(filters, null, Resource.EXECUTION);
+        return findAsync(defaultFilter(tenantId), condition);
+    }
+
     @Override
     public List<DailyExecutionStatistics> dailyStatisticsForAllTenants(
         @Nullable String query,
diff --git a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
index 93d7d1c7de..1f3364f5e2 100644
--- a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
+++ b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
@@ -46,11 +46,14 @@ import lombok.extern.slf4j.Slf4j;
 import org.jooq.*;
 import org.jooq.Record;
 import org.jooq.impl.DSL;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
 
 import java.io.IOException;
 import java.time.ZonedDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static io.kestra.core.utils.Rethrow.throwConsumer;
 
@@ -802,6 +805,48 @@ public abstract class AbstractJdbcFlowRepository extends AbstractJdbcRepository
             );
     }
 
+    @Override
+    public Flux<Flow> findAsync(String tenantId, List<QueryFilter> filters) {
+        return this.findAsync(tenantId, filters, Resource.FLOW);
+    }
+
+    protected Flux<Flow> findAsync(String tenantId, @Nullable List<QueryFilter> filters, QueryFilter.Resource resource) {
+        if (filters == null || filters.isEmpty()) {
+            return findAsync(defaultFilter(tenantId), null);
+        }
+        Condition condition = this.filter(filters, null, resource);
+        return findAsync(defaultFilter(tenantId), condition);
+    }
+
+    protected Flux<Flow> findAsync(Condition defaultFilter, Condition condition, OrderField<Flow>... orderByFields) {
+        return Flux.create(emitter -> this.jdbcRepository
+            .getDslContextWrapper()
+            .transaction(configuration -> {
+                DSLContext context = DSL.using(configuration);
+
+                var select = context
+                    .select(SOURCE_FIELD, VALUE_FIELD, NAMESPACE_FIELD, TENANT_FIELD)
+                    .from(this.jdbcRepository.getTable())
+                    .where(defaultFilter);
+
+                if (condition != null) {
+                    select = select.and(condition);
+                }
+
+                if (orderByFields != null) {
+                    select.orderBy(orderByFields);
+                }
+
+                try (Stream<Record4<String, String, String, String>> stream =  select.fetchSize(FETCH_SIZE).stream()){
+                    stream
+                        .map(record -> (Flow) jdbcRepository.map(record))
+                        .forEach(emitter::next);
+                } finally {
+                    emitter.complete();
+                }
+            }), FluxSink.OverflowStrategy.BUFFER);
+    }
+
     @Override
     public Integer lastRevision(String tenantId, String namespace, String id) {
         return this.jdbcRepository
diff --git a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTriggerRepository.java b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTriggerRepository.java
index f57f27747f..5d2c973a08 100644
--- a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTriggerRepository.java
+++ b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTriggerRepository.java
@@ -59,7 +59,7 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
 
     @Override
     public Triggers.Fields dateFilterField() {
-        return null;
+        return Triggers.Fields.NEXT_EXECUTION_DATE;
     }
 
     public AbstractJdbcTriggerRepository(io.kestra.jdbc.AbstractJdbcRepository<Trigger> jdbcRepository,
@@ -82,7 +82,7 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
 
     public List<Trigger> findByNextExecutionDateReadyForAllTenants(ZonedDateTime now, ScheduleContextInterface scheduleContextInterface) {
         JdbcSchedulerContext jdbcSchedulerContext = (JdbcSchedulerContext) scheduleContextInterface;
-        
+
         return jdbcSchedulerContext.getContext()
             .select(field("value"))
             .from(this.jdbcRepository.getTable())
@@ -98,9 +98,9 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
             .fetch()
             .map(r -> this.jdbcRepository.deserialize(r.get("value", String.class)));
     }
-    
+
     public List<Trigger> findByNextExecutionDateReadyButLockedTriggers(ZonedDateTime now) {
-        
+
         return this.jdbcRepository.getDslContextWrapper()
             .transactionResult(configuration -> DSL.using(configuration)
                 .select(field("value"))
@@ -115,7 +115,7 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
                 .fetch()
                 .map(r -> this.jdbcRepository.deserialize(r.get("value", String.class))));
     }
-    
+
     protected Temporal toNextExecutionTime(ZonedDateTime now) {
         return now.toOffsetDateTime();
     }
@@ -199,7 +199,7 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
     }
     @Override
     public ArrayListTotal<Trigger> find(Pageable pageable, String tenantId, List<QueryFilter> filters) {
-        var condition = filter(filters, "next_execution_date", Resource.TRIGGER);
+        var condition = filter(filters, fieldsMapping.get(dateFilterField()), Resource.TRIGGER);
         return findPage(pageable, tenantId, condition);
     }
 
@@ -223,11 +223,13 @@ public abstract class AbstractJdbcTriggerRepository extends AbstractJdbcCrudRepo
         return findPage(pageable, tenantId, condition);
     }
 
-    /** {@inheritDoc} */
     @Override
-    public Flux<Trigger> find(String tenantId, List<QueryFilter> filters) {
-        var condition = filter(filters, "next_execution_date", Resource.TRIGGER);
-        return findAsync(tenantId, condition);
+    public Flux<Trigger> findAsync(String tenantId, List<QueryFilter> filters) {
+        if (filters == null || filters.isEmpty()) {
+            return findAllAsync(tenantId);
+        }
+        Condition condition = this.filter(filters, fieldsMapping.get(dateFilterField()), Resource.TRIGGER);
+        return findAsync(defaultFilter(tenantId), condition);
     }
 
     protected Condition fullTextCondition(String query) {
diff --git a/ui/src/components/admin/Triggers.vue b/ui/src/components/admin/Triggers.vue
index 8b38495007..aed0c296dc 100644
--- a/ui/src/components/admin/Triggers.vue
+++ b/ui/src/components/admin/Triggers.vue
@@ -1,5 +1,11 @@
 <template>
-    <TopNavBar :title="routeInfo.title" />
+    <TopNavBar :title="routeInfo.title">
+        <template #additional-right>
+            <el-button :icon="Download" @click="exportTriggersAsStream()">
+                {{ t('auditlog.export_csv') }}
+            </el-button>
+        </template>
+    </TopNavBar>
     <section class="container" v-if="ready">
         <div>
             <DataTable
@@ -361,6 +367,7 @@
     import AlertCircle from "vue-material-design-icons/AlertCircle.vue";
     import CalendarCollapseHorizontalOutline from "vue-material-design-icons/CalendarCollapseHorizontalOutline.vue";
     import Delete from "vue-material-design-icons/Delete.vue";
+    import Download from "vue-material-design-icons/Download.vue";
 
     import Id from "../Id.vue";
     import Kicon from "../Kicon.vue";
@@ -831,6 +838,10 @@
             loadData(load);
         }
     });
+
+    async function exportTriggersAsStream() {
+        await triggerStore.exportTriggersAsCSV(route.query);
+    }
 </script>
 
 <style scoped lang="scss">
diff --git a/ui/src/components/executions/Executions.vue b/ui/src/components/executions/Executions.vue
index cd84602afa..19bbdb8d1e 100644
--- a/ui/src/components/executions/Executions.vue
+++ b/ui/src/components/executions/Executions.vue
@@ -3,6 +3,11 @@
         <template #additional-right v-if="displayButtons">
             <ul>
                 <template v-if="$route.name === 'executions/list'">
+                    <li>
+                        <el-button :icon="Download" @click="exportExecutionsAsStream()">
+                            {{ t('auditlog.export_csv') }}
+                        </el-button>
+                    </li>
                     <li>
                         <template v-if="hasAnyExecute">
                             <TriggerFlow />
@@ -404,6 +409,7 @@
     import PlayBoxMultiple from "vue-material-design-icons/PlayBoxMultiple.vue";
     import StopCircleOutline from "vue-material-design-icons/StopCircleOutline.vue";
     import QueueFirstInLastOut from "vue-material-design-icons/QueueFirstInLastOut.vue";
+    import Download from "vue-material-design-icons/Download.vue";
 
     import Id from "../Id.vue";
     import Kicon from "../Kicon.vue";
@@ -411,7 +417,7 @@
     import Labels from "../layout/Labels.vue";
     import DateAgo from "../layout/DateAgo.vue";
     import DataTable from "../layout/DataTable.vue";
-    import BulkSelect from "../layout/BulkSelect.vue";    
+    import BulkSelect from "../layout/BulkSelect.vue";
     import SelectTable from "../layout/SelectTable.vue";
     import KSFilter from "../filter/components/KSFilter.vue";
     import Sections from "../dashboard/sections/Sections.vue";
@@ -445,7 +451,7 @@
 
     const {t} = useI18n();
     const toast = useToast();
-    
+
     const executionFilter = useExecutionFilter();
     const flowExecutionFilter = useFlowExecutionFilter();
 
@@ -503,69 +509,69 @@
 
     const optionalColumns = ref([
         {
-            label: t("start date"), 
-            prop: "state.startDate", 
-            default: true, 
+            label: t("start date"),
+            prop: "state.startDate",
+            default: true,
             description: t("filter.table_column.executions.start-date")
         },
         {
-            label: t("end date"), 
-            prop: "state.endDate", 
-            default: true, 
+            label: t("end date"),
+            prop: "state.endDate",
+            default: true,
             description: t("filter.table_column.executions.end-date")
         },
         {
-            label: t("duration"), 
-            prop: "state.duration", 
-            default: true, 
+            label: t("duration"),
+            prop: "state.duration",
+            default: true,
             description: t("filter.table_column.executions.duration")
         },
         {
-            label: t("namespace"), 
-            prop: "namespace", 
-            default: true, 
+            label: t("namespace"),
+            prop: "namespace",
+            default: true,
             description: t("filter.table_column.executions.namespace")
         },
         {
-            label: t("flow"), 
-            prop: "flowId", 
-            default: true, 
+            label: t("flow"),
+            prop: "flowId",
+            default: true,
             description: t("filter.table_column.executions.flow")
         },
         {
-            label: t("labels"), 
-            prop: "labels", 
-            default: true, 
+            label: t("labels"),
+            prop: "labels",
+            default: true,
             description: t("filter.table_column.executions.labels")
         },
         {
-            label: t("state"), 
-            prop: "state.current", 
-            default: true, 
+            label: t("state"),
+            prop: "state.current",
+            default: true,
             description: t("filter.table_column.executions.state")
         },
         {
-            label: t("revision"), 
-            prop: "flowRevision", 
-            default: false, 
+            label: t("revision"),
+            prop: "flowRevision",
+            default: false,
             description: t("filter.table_column.executions.revision")
         },
         {
-            label: t("inputs"), 
-            prop: "inputs", 
-            default: false, 
+            label: t("inputs"),
+            prop: "inputs",
+            default: false,
             description: t("filter.table_column.executions.inputs")
         },
         {
-            label: t("outputs"), 
-            prop: "outputs", 
-            default: false, 
+            label: t("outputs"),
+            prop: "outputs",
+            default: false,
             description: t("filter.table_column.executions.outputs")
         },
         {
-            label: t("task id"), 
-            prop: "taskRunList.taskId", 
-            default: false, 
+            label: t("task id"),
+            prop: "taskRunList.taskId",
+            default: false,
             description: t("filter.table_column.executions.task-id")
         },
         {
@@ -576,9 +582,9 @@
         }
     ]);
 
-    const storageKey = computed(() => 
-        route.name === "flows/update" 
-            ? storageKeys.DISPLAY_FLOW_EXECUTIONS_COLUMNS 
+    const storageKey = computed(() =>
+        route.name === "flows/update"
+            ? storageKeys.DISPLAY_FLOW_EXECUTIONS_COLUMNS
             : storageKeys.DISPLAY_EXECUTIONS_COLUMNS
     );
 
@@ -587,7 +593,7 @@
         storageKey: storageKey.value
     });
 
-    const visibleColumns = computed(() => 
+    const visibleColumns = computed(() =>
         displayColumns.value
             .map(prop => optionalColumns.value.find(c => c.prop === prop))
             .filter(Boolean) as any[]
@@ -1047,6 +1053,12 @@
             executionLabels.value = [];
         }
     });
+
+    async function exportExecutionsAsStream() {
+        await executionsStore.exportExecutionsAsCSV(
+            route.query
+        )
+    }
 </script>
 
 
diff --git a/ui/src/components/flows/Flows.vue b/ui/src/components/flows/Flows.vue
index e84f783c56..e4b723882f 100644
--- a/ui/src/components/flows/Flows.vue
+++ b/ui/src/components/flows/Flows.vue
@@ -2,6 +2,11 @@
     <TopNavBar v-if="topbar" :title="routeInfo.title">
         <template #additional-right>
             <ul class="header-actions-list">
+                <li>
+                    <el-button v-if="canRead" :icon="Download" @click="exportFlowsAsStream()">
+                        {{ t('auditlog.export_csv') }}
+                    </el-button>
+                </li>
                 <li>
                     <el-button :icon="Upload" @click="file?.click()">
                         {{ t("import") }}
@@ -314,7 +319,7 @@
 
     const {t} = useI18n();
     const toast = useToast()
-    
+
     const flowFilter = useFlowFilter();
 
     const lastExecutionByFlowReady = ref(false);
@@ -323,39 +328,39 @@
 
     const optionalColumns = ref([
         {
-            label: t("labels"), 
-            prop: "labels", 
-            default: true, 
+            label: t("labels"),
+            prop: "labels",
+            default: true,
             description: t("filter.table_column.flows.labels")
         },
         {
-            label: t("namespace"), 
-            prop: "namespace", 
-            default: true, 
+            label: t("namespace"),
+            prop: "namespace",
+            default: true,
             description: t("filter.table_column.flows.namespace")
         },
         {
-            label: t("last execution date"), 
-            prop: "state.startDate", 
-            default: true, 
+            label: t("last execution date"),
+            prop: "state.startDate",
+            default: true,
             description: t("filter.table_column.flows.last execution date")
         },
         {
-            label: t("last execution status"), 
-            prop: "state.current", 
-            default: true, 
+            label: t("last execution status"),
+            prop: "state.current",
+            default: true,
             description: t("filter.table_column.flows.last execution status")
         },
         {
-            label: t("execution statistics"), 
-            prop: "state", 
-            default: true, 
+            label: t("execution statistics"),
+            prop: "state",
+            default: true,
             description: t("filter.table_column.flows.execution statistics")
         },
         {
-            label: t("triggers"), 
-            prop: "triggers", 
-            default: true, 
+            label: t("triggers"),
+            prop: "triggers",
+            default: true,
             description: t("filter.table_column.flows.triggers")
         },
     ]);
@@ -405,9 +410,9 @@
     }
 
     const {
-        queryWithFilter, 
-        onPageChanged, 
-        onRowDoubleClick, 
+        queryWithFilter,
+        onPageChanged,
+        onRowDoubleClick,
         onSort,
         ready
     } = useDataTableActions({
@@ -425,10 +430,10 @@
     }
 
     const {
-        selection, 
-        queryBulkAction, 
-        handleSelectionChange, 
-        toggleAllUnselected, 
+        selection,
+        queryBulkAction,
+        handleSelectionChange,
+        toggleAllUnselected,
         toggleAllSelection
     } = useSelectTableActions({
         dataTableRef: selectTableRef,
@@ -631,6 +636,12 @@
             operation: "EQUALS"
         }];
     }
+
+    async function exportFlowsAsStream() {
+        await flowStore.exportFlowAsCSV(
+            route.query
+        )
+    }
 </script>
 
 <style scoped lang="scss">
diff --git a/ui/src/stores/executions.ts b/ui/src/stores/executions.ts
index f9c8cfe52b..cfd6c35d20 100644
--- a/ui/src/stores/executions.ts
+++ b/ui/src/stores/executions.ts
@@ -707,6 +707,21 @@ export const useExecutionsStore = defineStore("executions", () => {
         });
     }
 
+    const exportExecutionsAsCSV = async (params: any) => {
+        const response = await axios.get(
+            `${apiUrl()}/executions/export/by-query/csv`,
+            {params, responseType: "blob"}
+        );
+        const url = window.URL.createObjectURL(new Blob([response.data]));
+        const link = document.createElement("a");
+        link.href = url;
+        link.setAttribute("download", "executions.csv");
+        document.body.appendChild(link);
+        link.click();
+        link.remove();
+        window.URL.revokeObjectURL(url);
+    }
+
     return {
         // State
         executions,
@@ -781,5 +796,6 @@ export const useExecutionsStore = defineStore("executions", () => {
         appendLogs,
         appendFollowedLogs,
         getFlowExecutions,
+        exportExecutionsAsCSV
     };
 });
diff --git a/ui/src/stores/flow.ts b/ui/src/stores/flow.ts
index 65e4fedcae..566a443083 100644
--- a/ui/src/stores/flow.ts
+++ b/ui/src/stores/flow.ts
@@ -175,7 +175,7 @@ export const useFlowStore = defineStore("flow", () => {
                 if (flowBeforeEdit &&
                         (flowOnValidation.id !== flowBeforeEdit.id ||
                             flowOnValidation.namespace !== flowBeforeEdit.namespace)) {
-                    
+
                     coreStore.message = {
                         variant: "error",
                         title: t("readonly property"),
@@ -609,6 +609,22 @@ function deleteFlowAndDependencies() {
                 Utils.downloadUrl(response.request.responseURL, "flows.zip");
             });
     }
+
+    async function exportFlowAsCSV(params: any) {
+        const response = await axios.get(
+            `${apiUrl()}/flows/export/by-query/csv`,
+            {params, responseType: "blob"}
+        );
+        const url = window.URL.createObjectURL(new Blob([response.data]));
+        const link = document.createElement("a");
+        link.href = url;
+        link.setAttribute("download", "flows.csv");
+        document.body.appendChild(link);
+        link.click();
+        link.remove();
+        window.URL.revokeObjectURL(url);
+    }
+
     function importFlows(options: { file: File, namespace: string, override?: boolean }) {
         return axios.post(`${apiUrl()}/flows/import`, Utils.toFormData(options), {
             headers: {"Content-Type": "multipart/form-data"}
@@ -871,6 +887,7 @@ function deleteFlowAndDependencies() {
         loadRevisions,
         exportFlowByIds,
         exportFlowByQuery,
+        exportFlowAsCSV,
         importFlows,
         disableFlowByIds,
         disableFlowByQuery,
diff --git a/ui/src/stores/trigger.ts b/ui/src/stores/trigger.ts
index e34f96cbbe..df44460661 100644
--- a/ui/src/stores/trigger.ts
+++ b/ui/src/stores/trigger.ts
@@ -155,5 +155,17 @@ export const useTriggerStore = defineStore("trigger", {
             const response = await this.$http.delete(`${apiUrl()}/triggers/delete/by-triggers`, {data: options});
             return response.data;
         },
+
+        async exportTriggersAsCSV(options: any) {
+            const response = await this.$http.get(`${apiUrl()}/triggers/export/by-query/csv`, {params: options, responseType: "blob"});
+            const url = window.URL.createObjectURL(new Blob([response.data]));
+            const link = document.createElement("a");
+            link.href = url;
+            link.setAttribute("download", "triggers.csv");
+            document.body.appendChild(link);
+            link.click();
+            link.remove();
+            window.URL.revokeObjectURL(url);
+        },
     }
 });
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/api/ExecutionController.java b/webserver/src/main/java/io/kestra/webserver/controllers/api/ExecutionController.java
index b7b7501a85..ae63a96b32 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/api/ExecutionController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/api/ExecutionController.java
@@ -1,5 +1,6 @@
 package io.kestra.webserver.controllers.api;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.debug.Breakpoint;
 import io.kestra.core.events.CrudEvent;
@@ -45,7 +46,9 @@ import io.kestra.webserver.responses.BulkResponse;
 import io.kestra.webserver.responses.PagedResults;
 import io.kestra.webserver.services.ExecutionDependenciesStreamingService;
 import io.kestra.webserver.services.ExecutionStreamingService;
+import io.kestra.webserver.utils.CSVUtils;
 import io.kestra.webserver.utils.PageableUtils;
+import io.kestra.webserver.utils.QueryFilterUtils;
 import io.kestra.webserver.utils.RequestUtils;
 import io.kestra.webserver.utils.filepreview.FileRender;
 import io.kestra.webserver.utils.filepreview.FileRenderBuilder;
@@ -72,9 +75,9 @@ import io.opentelemetry.context.propagation.ContextPropagators;
 import io.opentelemetry.context.propagation.TextMapPropagator;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.extensions.Extension;
 import io.swagger.v3.oas.annotations.extensions.ExtensionProperty;
-import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.ExampleObject;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -197,13 +200,16 @@ public class ExecutionController {
 
     @Inject
     private SecureVariableRendererFactory secureVariableRendererFactory;
-    
+
     @Inject
     private LogService logService;
 
     @Value("${" + LocalPath.ENABLE_PREVIEW_CONFIG + ":true}")
     private boolean enableLocalFilePreview;
 
+    @Inject
+    private ObjectMapper objectMapper;
+
     @ExecuteOn(TaskExecutors.IO)
     @Get(uri = "/search")
     @Operation(tags = {"Executions"}, summary = "Search for executions")
@@ -741,7 +747,7 @@ public class ExecutionController {
                         "Flow execution blocked: one or more condition checks evaluated to false."
                     ));
                 }
-                
+
                 final Execution executionWithInputs = Optional.of(current.withInputs(executionInputs))
                     .map(exec -> {
                         if (Check.Behavior.FAIL_EXECUTION.equals(behavior)) {
@@ -752,7 +758,7 @@ public class ExecutionController {
                         }
                     })
                     .get();
-                
+
                 try {
                     // inject the traceparent into the execution
                     openTelemetry
@@ -2570,6 +2576,23 @@ public class ExecutionController {
         ).stream().map(LastExecutionResponse::ofExecution).toList();
     }
 
+    @Get(uri = "/export/by-query/csv", produces = MediaType.TEXT_CSV)
+    @ExecuteOn(TaskExecutors.IO)
+    @Operation(tags = {"Executions"}, summary = "Export all executions as a streamed CSV file")
+    @SuppressWarnings("unchecked")
+    public MutableHttpResponse<Flux> exportExecutions(
+        @Parameter(description = "A list of filters", in = ParameterIn.QUERY) @QueryFilterFormat List<QueryFilter> filters
+    ) {
+
+        return HttpResponse.ok(
+                CSVUtils.toCSVFlux(
+                   executionRepository.findAsync(this.tenantService.resolveTenant(), QueryFilterUtils.replaceTimeRangeWithComputedStartDateFilter(filters))
+                        .map(log -> objectMapper.convertValue(log, Map.class))
+                )
+            )
+            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=executions.csv");
+    }
+
     @Introspected
     public record LastExecutionResponse(
         @Parameter(description = "The execution's ID") String id,
@@ -2622,7 +2645,7 @@ public class ExecutionController {
             String message
         ) {
         }
-        
+
         @Introspected
         public record ApiCheckFailure(
             @Parameter(description = "The message")
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/api/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/api/FlowController.java
index 1533319adf..da09cb02e4 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/api/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/api/FlowController.java
@@ -1,6 +1,7 @@
 package io.kestra.webserver.controllers.api;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import io.kestra.core.exceptions.FlowProcessingException;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.InternalException;
@@ -29,14 +30,13 @@ import io.kestra.webserver.controllers.domain.IdWithNamespace;
 import io.kestra.webserver.converters.QueryFilterFormat;
 import io.kestra.webserver.responses.BulkResponse;
 import io.kestra.webserver.responses.PagedResults;
+import io.kestra.webserver.utils.CSVUtils;
 import io.kestra.webserver.utils.PageableUtils;
 import io.kestra.webserver.utils.RequestUtils;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.core.convert.format.Format;
 import io.micronaut.data.model.Pageable;
-import io.micronaut.http.HttpResponse;
-import io.micronaut.http.HttpStatus;
-import io.micronaut.http.MediaType;
+import io.micronaut.http.*;
 import io.micronaut.http.annotation.*;
 import io.micronaut.http.exceptions.HttpStatusException;
 import io.micronaut.http.multipart.CompletedFileUpload;
@@ -57,6 +57,7 @@ import jakarta.validation.Valid;
 import jakarta.validation.constraints.Min;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
+import reactor.core.publisher.Flux;
 
 import java.io.IOException;
 import java.util.*;
@@ -90,6 +91,9 @@ public class FlowController {
     @Inject
     private TenantService tenantService;
 
+    @Inject
+    private ObjectMapper objectMapper;
+
 
     @ExecuteOn(TaskExecutors.IO)
     @Get(uri = "{namespace}/{id}/graph")
@@ -897,6 +901,22 @@ public class FlowController {
         return HttpResponse.ok(wrongFiles);
     }
 
+    @Get(uri = "/export/by-query/csv", produces = MediaType.TEXT_CSV)
+    @ExecuteOn(TaskExecutors.IO)
+    @Operation(tags = {"Flows"}, summary = "Export all flows as a streamed CSV file")
+    @SuppressWarnings("unchecked")
+    public MutableHttpResponse<Flux> exportFlows(
+        @Parameter(description = "A list of filters", in = ParameterIn.QUERY) @QueryFilterFormat List<QueryFilter> filters
+    ) {
+        return HttpResponse.ok(
+                CSVUtils.toCSVFlux(
+                    flowRepository.findAsync(this.tenantService.resolveTenant(), filters)
+                        .map(log -> objectMapper.convertValue(log, Map.class))
+                )
+            )
+            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=flows.csv");
+    }
+
     protected GenericFlow parseFlowSource(final String source) {
         return GenericFlow.fromYaml(tenantService.resolveTenant(), source);
     }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/api/TriggerController.java b/webserver/src/main/java/io/kestra/webserver/controllers/api/TriggerController.java
index 43c3d97edc..86440bb72d 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/api/TriggerController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/api/TriggerController.java
@@ -1,5 +1,6 @@
 package io.kestra.webserver.controllers.api;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.conditions.ConditionContext;
 import io.kestra.core.models.executions.ExecutionKilled;
@@ -15,16 +16,14 @@ import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.RunContextFactory;
 import io.kestra.core.services.ConditionService;
 import io.kestra.core.tenant.TenantService;
-import io.kestra.plugin.core.trigger.Schedule;
 import io.kestra.webserver.converters.QueryFilterFormat;
 import io.kestra.webserver.responses.BulkResponse;
 import io.kestra.webserver.responses.PagedResults;
+import io.kestra.webserver.utils.CSVUtils;
 import io.kestra.webserver.utils.PageableUtils;
 import io.kestra.webserver.utils.RequestUtils;
 import io.micronaut.core.annotation.Nullable;
-import io.micronaut.http.HttpResponse;
-import io.micronaut.http.HttpStatus;
-import io.micronaut.http.MutableHttpResponse;
+import io.micronaut.http.*;
 import io.micronaut.http.annotation.*;
 import io.micronaut.http.exceptions.HttpStatusException;
 import io.micronaut.scheduling.TaskExecutors;
@@ -41,10 +40,12 @@ import jakarta.validation.constraints.NotNull;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
+import reactor.core.publisher.Flux;
 
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -76,6 +77,9 @@ public class TriggerController {
     @Inject
     private ConditionService conditionService;
 
+    @Inject
+    private ObjectMapper objectMapper;
+
     @ExecuteOn(TaskExecutors.IO)
     @Get(uri = "/search")
     @Operation(tags = {"Triggers"}, summary = "Search for triggers")
@@ -224,7 +228,7 @@ public class TriggerController {
             null);
 
         Integer count = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .filter(trigger -> trigger.getExecutionId() != null || trigger.getEvaluateRunningDate() != null)
             .map(trigger -> {
                 try {
@@ -375,7 +379,7 @@ public class TriggerController {
     ) throws QueueException {
         // Updating the backfill within the flux does not works
         List<Trigger> triggers = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .collectList().block();
 
         int count = triggers == null ? 0 : backfillsAction(triggers, BACKFILL_ACTION.PAUSE);
@@ -428,7 +432,7 @@ public class TriggerController {
 
         // Updating the backfill within the flux does not works
         List<Trigger> triggers = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .collectList().block();
 
         int count = triggers == null ? 0 : backfillsAction(triggers, BACKFILL_ACTION.UNPAUSE);
@@ -497,7 +501,7 @@ public class TriggerController {
 
         // Updating the backfill within the flux does not works
         List<Trigger> triggers = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .collectList().block();
 
         int count = triggers == null ? 0 : backfillsAction(triggers, BACKFILL_ACTION.DELETE);
@@ -564,7 +568,7 @@ public class TriggerController {
         @Parameter(description = "Filters") @QueryFilterFormat List<QueryFilter> filters
     ) {
         Integer count = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .map(trigger -> {
                 try {
                     triggerRepository.delete(trigger);
@@ -616,7 +620,7 @@ public class TriggerController {
             null);
 
         Integer count = triggerRepository
-            .find(tenantService.resolveTenant(), filters)
+            .findAsync(tenantService.resolveTenant(), filters)
             .map(throwFunction(trigger -> {
                 this.setTriggerDisabled(trigger, disabled);
                 return 1;
@@ -628,6 +632,23 @@ public class TriggerController {
         return HttpResponse.ok(BulkResponse.builder().count(count).build());
     }
 
+    @Get(uri = "/export/by-query/csv", produces = MediaType.TEXT_CSV)
+    @ExecuteOn(TaskExecutors.IO)
+    @Operation(tags = {"Triggers"}, summary = "Export all triggers as a streamed CSV file")
+    @SuppressWarnings("unchecked")
+    public MutableHttpResponse<Flux> exportTriggers(
+        @Parameter(description = "A list of filters", in = ParameterIn.QUERY) @QueryFilterFormat List<QueryFilter> filters
+    ) {
+
+        return HttpResponse.ok(
+                CSVUtils.toCSVFlux(
+                    triggerRepository.findAsync(this.tenantService.resolveTenant(), filters)
+                        .map(log -> objectMapper.convertValue(log, Map.class))
+                )
+            )
+            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=triggers.csv");
+    }
+
     public void setTriggerDisabled(Trigger trigger, Boolean disabled) throws QueueException {
         Optional<Flow> maybeFlow = this.flowRepository.findById(this.tenantService.resolveTenant(), trigger.getNamespace(), trigger.getFlowId());
 
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
index ad74b42b65..83896705c4 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
@@ -4,12 +4,15 @@ import com.google.common.collect.ImmutableMap;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.models.Label;
 import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.FlowForExecution;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.TaskForExecution;
 import io.kestra.core.models.triggers.AbstractTriggerForExecution;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.core.utils.TestsUtils;
 import io.kestra.jdbc.JdbcTestUtils;
+import io.kestra.plugin.core.debug.Return;
 import io.kestra.webserver.responses.BulkResponse;
 import io.kestra.webserver.responses.PagedResults;
 import io.micronaut.core.type.Argument;
@@ -227,11 +230,11 @@ class ExecutionControllerTest {
         assertThat(response.getStatus().getCode()).isEqualTo(HttpStatus.NO_CONTENT.getCode());
         assertThat(response.body()).isNull();
     }
-    
+
     @Test
     void webhookWithInputs() {
         record Hello(String hello) {}
-        
+
         Execution execution = client.toBlocking().retrieve(
             HttpRequest
                 .POST(
@@ -240,11 +243,11 @@ class ExecutionControllerTest {
                 ),
             Execution.class
         );
-        
+
         assertThat(execution).isNotNull();
         assertThat(execution.getId()).isNotNull();
     }
-    
+
     @Test
     void resolveAbsoluteDateTime() {
         final ZonedDateTime absoluteTimestamp = ZonedDateTime.of(2023, 2, 3, 4, 6,10, 0, ZoneId.systemDefault());
@@ -256,7 +259,6 @@ class ExecutionControllerTest {
         assertThrows(IllegalArgumentException.class, () -> executionController.resolveAbsoluteDateTime(absoluteTimestamp, offset, baseTimestamp));
     }
 
-
     @Test
     void nullLabels() {
         MultipartBody requestBody = createExecutionInputsFlowBody();
@@ -487,7 +489,7 @@ class ExecutionControllerTest {
     }
 
     @Test
-   void shouldHaveAnUrlWhenCreated() {
+    void shouldHaveAnUrlWhenCreated() {
         // ExecutionController.ExecutionResponse cannot be deserialized because it didn't have any default constructor.
         // adding it would mean updating the Execution itself, which is too annoying, so for the test we just deserialize to a Map.
         Map<?, ?> executionResult = client.toBlocking().retrieve(
@@ -512,4 +514,40 @@ class ExecutionControllerTest {
 
         assertThat(error.getStatus().getCode()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY.getCode());
     }
+
+    @Test
+    void exportExecutions() {
+        createAndExecuteFlow();
+
+        HttpResponse<byte[]> response = client.toBlocking().exchange(
+            HttpRequest.GET("/api/v1/main/executions/export"),
+            byte[].class
+        );
+
+        assertThat(response.getStatus().getCode()).isEqualTo(HttpStatus.OK.getCode());
+        assertThat(response.getHeaders().get("Content-Disposition")).contains("attachment; filename=executions.csv");
+        String csv = new String(response.body());
+        assertThat(csv).contains("id");
+    }
+
+    void createAndExecuteFlow() {
+        String namespaceId = "io.othercompany";
+        String flowId = "flowId";
+        Flow create = Flow.builder()
+            .id(flowId)
+            .tenantId(MAIN_TENANT)
+            .namespace(namespaceId)
+            .tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format(Property.of("test")).build()))
+            .build();
+
+        client.toBlocking().retrieve(
+            HttpRequest.POST("/api/v1/main/flows", create),
+            Flow.class
+        );
+
+        client.toBlocking().retrieve(
+            HttpRequest.POST("/api/v1/main/executions/" + namespaceId + "/" + flowId, null),
+            Execution.class
+        );
+    }
 }
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/api/FlowControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/api/FlowControllerTest.java
index ac01f0a33d..ebdfe85ff8 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/api/FlowControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/api/FlowControllerTest.java
@@ -74,6 +74,8 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 class FlowControllerTest {
     private static final String TEST_NAMESPACE = "io.kestra.unittest";
 
+    public static final String FLOW_PATH = "/api/v1/main/flows";
+
     @Inject
     @Client("/")
     ReactorHttpClient client;
@@ -1098,6 +1100,34 @@ class FlowControllerTest {
         assertThat(result.getEdges().size()).isEqualTo(4);
     }
 
+    @Test
+    void exportFlows() {
+        Flow f1 = generateFlow("flow_export_1", "io.kestra.export", "a");
+        Flow f2 = generateFlow("flow_export_2", "io.kestra.export", "b");
+
+        client.toBlocking().retrieve(
+            HttpRequest.POST(FLOW_PATH, f1),
+            Flow.class
+        );
+        client.toBlocking().retrieve(
+            HttpRequest.POST(FLOW_PATH, f2),
+            Flow.class
+        );
+
+        HttpResponse<byte[]> response = client.toBlocking().exchange(
+            HttpRequest.GET(FLOW_PATH + "/export"),
+            byte[].class
+        );
+
+        assertThat(response.getStatus().getCode()).isEqualTo(HttpStatus.OK.getCode());
+        assertThat(response.getHeaders().get("Content-Disposition")).contains("attachment; filename=flows.csv");
+        String csv = new String(response.body());
+        assertThat(csv).contains("id");
+        assertThat(csv).contains(f1.getId());
+        assertThat(csv).contains(f2.getId());
+    }
+
+
     private Flow generateFlow(String namespace, String inputName) {
         return generateFlow(IdUtils.create(), namespace, inputName);
     }
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/api/TriggerControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/api/TriggerControllerTest.java
index 6f64afb53f..856fc79da6 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/api/TriggerControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/api/TriggerControllerTest.java
@@ -16,6 +16,7 @@ import io.kestra.jdbc.JdbcTestUtils;
 import io.kestra.jdbc.repository.AbstractJdbcFlowRepository;
 import io.kestra.jdbc.repository.AbstractJdbcTriggerRepository;
 import io.kestra.plugin.core.debug.Return;
+import io.kestra.plugin.core.log.Log;
 import io.kestra.plugin.core.trigger.Schedule;
 import io.kestra.webserver.controllers.api.TriggerController.SetDisabledRequest;
 import io.kestra.webserver.responses.BulkResponse;
@@ -39,15 +40,34 @@ import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.TimeoutException;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.groups.Tuple.tuple;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @KestraTest(startRunner = true, startScheduler = true)
 class TriggerControllerTest {
-
     public static final String TENANT_ID = TenantService.MAIN_TENANT;
     public static final String TRIGGER_PATH = "/api/v1/main/triggers";
+
+    public static final Trigger TRIGGER = Trigger.builder()
+        .flowId(IdUtils.create())
+        .namespace("io.kestra.unit-test")
+        .tenantId(MAIN_TENANT)
+        .triggerId(IdUtils.create())
+        .executionId(IdUtils.create())
+        .date(ZonedDateTime.now())
+        .evaluateRunningDate(ZonedDateTime.now())
+        .build();
+
+    public static final Flow FLOW = Flow.builder()
+        .id(TRIGGER.getFlowId())
+        .namespace("io.kestra.unit-test")
+        .tenantId(MAIN_TENANT)
+        .revision(1)
+        .tasks(Collections.singletonList(Log.builder().id("test").type(Log.class.getName()).message("{{ parent.outputs.args['my-forward'] }}").build()))
+        .triggers(List.of(Schedule.builder().id(TRIGGER.getTriggerId()).type(Schedule.class.getName()).cron("* * * * *").build()))
+        .build();
     @Inject
     @Client("/")
     ReactorHttpClient client;
@@ -593,6 +613,29 @@ class TriggerControllerTest {
         assertThat(deletedTrigger.isPresent()).isFalse();
     }
 
+    @Test
+    void exportTriggers() {
+        jdbcFlowRepository.create(GenericFlow.of(FLOW));
+
+        Trigger t1 = TRIGGER.toBuilder().triggerId(IdUtils.create()).build();
+        Trigger t2 = TRIGGER.toBuilder().triggerId(IdUtils.create()).build();
+        jdbcTriggerRepository.save(t1);
+        jdbcTriggerRepository.save(t2);
+
+        HttpResponse<byte[]> response = client.toBlocking().exchange(
+            HttpRequest.GET(TRIGGER_PATH + "/export"),
+            byte[].class
+        );
+
+        assertThat(response.getStatus().getCode()).isEqualTo(HttpStatus.OK.getCode());
+        assertThat(response.getHeaders().get("Content-Disposition")).contains("attachment; filename=triggers.csv");
+        String csv = new String(response.body());
+        assertThat(csv).contains("triggerId");
+
+        assertThat(csv).contains(t1.getTriggerId());
+        assertThat(csv).contains(t2.getTriggerId());
+    }
+
     private Flow createTestFlow() {
         return Flow.builder()
             .id("trigger-test-flow")