diff --git a/cypress/integration/funnels.js b/cypress/integration/funnels.js
index 2e059aa785dfb..7a14ecd1f1bd7 100644
--- a/cypress/integration/funnels.js
+++ b/cypress/integration/funnels.js
@@ -23,6 +23,9 @@ describe('Funnels', () => {
         cy.get('[data-attr=date-filter]').click()
         cy.contains('Last 30 days').click()
 
+        cy.get('[data-attr=date-filter]').click()
+        cy.contains('Last 30 days').click()
+
         cy.get('[data-attr=funnel-viz]').should('exist')
     })
 
diff --git a/dump.rdb b/dump.rdb
new file mode 100644
index 0000000000000..cf5bc0109c957
Binary files /dev/null and b/dump.rdb differ
diff --git a/frontend/src/lib/components/AppEditorLink/appUrlsLogic.js b/frontend/src/lib/components/AppEditorLink/appUrlsLogic.js
index 730e0ce175cbf..790a854dac723 100644
--- a/frontend/src/lib/components/AppEditorLink/appUrlsLogic.js
+++ b/frontend/src/lib/components/AppEditorLink/appUrlsLogic.js
@@ -23,7 +23,7 @@ export const appUrlsLogic = kea({
                     events: [{ id: '$pageview', name: '$pageview', type: 'events' }],
                     breakdown: '$current_url',
                 }
-                let data = await api.get('api/action/trends/?' + toParams(params))
+                let data = await api.get('api/insight/trend/?' + toParams(params))
                 if (data[0]?.count === 0) return []
                 let domainsSeen = []
                 return data
diff --git a/frontend/src/models/funnelsModel.ts b/frontend/src/models/funnelsModel.ts
index c0dda30c0730d..171eb451229ad 100644
--- a/frontend/src/models/funnelsModel.ts
+++ b/frontend/src/models/funnelsModel.ts
@@ -3,9 +3,9 @@ import api from 'lib/api'
 import { toParams } from 'lib/utils'
 import { ViewType } from 'scenes/insights/insightLogic'
 import { SavedFunnel } from '~/types'
-import { funnelsModelType } from './funnelsModelType'
 import { insightHistoryLogic } from 'scenes/insights/InsightHistoryPanel/insightHistoryLogic'
 import { funnelLogic } from 'scenes/funnels/funnelLogic'
+import { funnelsModelType } from 'types/models/funnelsModelType'
 
 const parseSavedFunnel = (result: Record<string, any>): SavedFunnel => {
     return {
@@ -25,7 +25,7 @@ export const funnelsModel = kea<funnelsModelType<SavedFunnel>>({
             __default: [] as SavedFunnel[],
             loadFunnels: async () => {
                 const response = await api.get(
-                    'api/dashboard_item/?' +
+                    'api/insight/?' +
                         toParams({
                             order: '-created_at',
                             saved: true,
diff --git a/frontend/src/scenes/funnels/funnelLogic.js b/frontend/src/scenes/funnels/funnelLogic.js
index 009e1bdea4351..dc90214cd669b 100644
--- a/frontend/src/scenes/funnels/funnelLogic.js
+++ b/frontend/src/scenes/funnels/funnelLogic.js
@@ -12,12 +12,12 @@ function wait(ms = 1000) {
 const SECONDS_TO_POLL = 120
 
 export async function pollFunnel(params = {}) {
-    let result = await api.get('api/action/funnel/?' + toParams(params))
+    let result = await api.get('api/insight/funnel/?' + toParams(params))
     let count = 0
     while (result.loading && count < SECONDS_TO_POLL) {
         await wait()
         const { refresh: _, ...restParams } = params
-        result = await api.get('api/action/funnel/?' + toParams(restParams))
+        result = await api.get('api/insight/funnel/?' + toParams(restParams))
         count += 1
     }
     // if endpoint is still loading after 2 minutes just return default
@@ -139,7 +139,7 @@ export const funnelLogic = kea({
             actions.setSteps(result)
         },
         saveFunnelInsight: async ({ name }) => {
-            await api.create('api/dashboard_item', {
+            await api.create('api/insight', {
                 filters: values.filters,
                 name,
                 saved: true,
diff --git a/frontend/src/scenes/insights/InsightHistoryPanel/InsightHistoryPanel.tsx b/frontend/src/scenes/insights/InsightHistoryPanel/InsightHistoryPanel.tsx
index 45198d8933954..68a90a82b3855 100644
--- a/frontend/src/scenes/insights/InsightHistoryPanel/InsightHistoryPanel.tsx
+++ b/frontend/src/scenes/insights/InsightHistoryPanel/InsightHistoryPanel.tsx
@@ -61,7 +61,7 @@ export const determineFilters = (
     } else if (viewType === ViewType.RETENTION) {
         if (filters.target) result.push({ key: 'Target', value: `${filters.target.name}` })
     } else if (viewType === ViewType.PATHS) {
-        if (filters.type) result.push({ key: 'Path Type', value: `${filters.type}` })
+        if (filters.type) result.push({ key: 'Path Type', value: `${filters.type || filters.path_type}` })
         if (filters.start) result.push({ key: 'Start Point', value: `Specified` })
     } else if (viewType === ViewType.FUNNELS) {
         let count = 0
diff --git a/frontend/src/scenes/insights/InsightHistoryPanel/insightHistoryLogic.ts b/frontend/src/scenes/insights/InsightHistoryPanel/insightHistoryLogic.ts
index 0b5521a8f3bf3..1f7dc9ce1adf8 100644
--- a/frontend/src/scenes/insights/InsightHistoryPanel/insightHistoryLogic.ts
+++ b/frontend/src/scenes/insights/InsightHistoryPanel/insightHistoryLogic.ts
@@ -40,7 +40,7 @@ export const insightHistoryLogic = kea<insightHistoryLogicType<InsightHistory>>(
             __default: [] as InsightHistory[],
             loadInsights: async () => {
                 const response = await api.get(
-                    'api/dashboard_item/?' +
+                    'api/insight/?' +
                         toParams({
                             order: '-created_at',
                             limit: 6,
@@ -57,7 +57,7 @@ export const insightHistoryLogic = kea<insightHistoryLogicType<InsightHistory>>(
             __default: [] as InsightHistory[],
             loadSavedInsights: async () => {
                 const response = await api.get(
-                    'api/dashboard_item/?' +
+                    'api/insight/?' +
                         toParams({
                             order: '-created_at',
                             saved: true,
@@ -75,7 +75,7 @@ export const insightHistoryLogic = kea<insightHistoryLogicType<InsightHistory>>(
             __default: [] as InsightHistory[],
             loadTeamInsights: async () => {
                 const response = await api.get(
-                    'api/dashboard_item/?' +
+                    'api/insight/?' +
                         toParams({
                             order: '-created_at',
                             saved: true,
@@ -156,13 +156,13 @@ export const insightHistoryLogic = kea<insightHistoryLogicType<InsightHistory>>(
     }),
     listeners: ({ actions, values }) => ({
         createInsight: async ({ filters }) => {
-            await api.create('api/dashboard_item', {
+            await api.create('api/insight', {
                 filters,
             })
             actions.loadInsights()
         },
         saveInsight: async ({ insight: { id }, name }) => {
-            await api.update(`api/dashboard_item/${id}`, {
+            await api.update(`api/insight/${id}`, {
                 name,
                 saved: true,
             })
@@ -172,7 +172,7 @@ export const insightHistoryLogic = kea<insightHistoryLogicType<InsightHistory>>(
         },
         deleteInsight: ({ insight }) => {
             deleteWithUndo({
-                endpoint: 'dashboard_item',
+                endpoint: 'insight',
                 object: { name: insight.name, id: insight.id },
                 callback: () => actions.loadSavedInsights(),
             })
diff --git a/frontend/src/scenes/insights/InsightTabs/PathTab.tsx b/frontend/src/scenes/insights/InsightTabs/PathTab.tsx
index 895d876c0c4ca..3692e02768cd2 100644
--- a/frontend/src/scenes/insights/InsightTabs/PathTab.tsx
+++ b/frontend/src/scenes/insights/InsightTabs/PathTab.tsx
@@ -22,10 +22,10 @@ export function PathTab(): JSX.Element {
         <>
             <h4 className="secondary">Path Type</h4>
             <Select
-                value={filter?.type || PAGEVIEW}
+                value={filter?.path_type || PAGEVIEW}
                 defaultValue={PAGEVIEW}
                 dropdownMatchSelectWidth={false}
-                onChange={(value): void => setFilter({ type: value, start: null })}
+                onChange={(value): void => setFilter({ path_type: value, start_point: null })}
                 style={{ paddingTop: 2 }}
             >
                 {Object.entries(pathOptionsToLabels).map(([value, name], index) => {
@@ -39,18 +39,18 @@ export function PathTab(): JSX.Element {
             <hr />
             <h4 className="secondary">Start Point</h4>
             <PropertyValue
-                endpoint={filter?.type === AUTOCAPTURE && 'api/paths/elements'}
+                endpoint={filter?.path_type === AUTOCAPTURE && 'api/paths/elements'}
                 outerOptions={
                     filter.type === CUSTOM_EVENT &&
                     customEventNames.map((name) => ({
                         name,
                     }))
                 }
-                onSet={(value): void => setFilter({ start: value })}
-                propertyKey={pathOptionsToProperty[filter.type]}
+                onSet={(value): void => setFilter({ start_point: value })}
+                propertyKey={pathOptionsToProperty[filter.path_type]}
                 type="event"
                 style={{ width: 200, paddingTop: 2 }}
-                value={filter.start}
+                value={filter.start_point}
                 placeholder={'Select start element'}
             ></PropertyValue>
             <hr />
diff --git a/frontend/src/scenes/insights/trendsLogic.js b/frontend/src/scenes/insights/trendsLogic.js
index 37a8405831cd8..65565779d4d9a 100644
--- a/frontend/src/scenes/insights/trendsLogic.js
+++ b/frontend/src/scenes/insights/trendsLogic.js
@@ -125,14 +125,14 @@ export const trendsLogic = kea({
                 let response
                 if (props.view === ViewType.SESSIONS || props.filters?.session) {
                     response = await api.get(
-                        'api/event/sessions/?' +
+                        'api/insight/session/?' +
                             (refresh ? 'refresh=true&' : '') +
                             toAPIParams(filterClientSideParams(values.filters))
                     )
                     response = response.result
                 } else {
                     response = await api.get(
-                        'api/action/trends/?' +
+                        'api/insight/trend/?' +
                             (refresh ? 'refresh=true&' : '') +
                             toAPIParams(filterClientSideParams(values.filters))
                     )
diff --git a/frontend/src/scenes/paths/Paths.js b/frontend/src/scenes/paths/Paths.js
index 623b00b8d1a15..a289c2fcdc14e 100644
--- a/frontend/src/scenes/paths/Paths.js
+++ b/frontend/src/scenes/paths/Paths.js
@@ -189,14 +189,14 @@ export function Paths() {
                     : stripHTTP(d.name)
             )
             .on('click', async (node) => {
-                if (filter.type == AUTOCAPTURE) {
+                if (filter.path_type == AUTOCAPTURE) {
                     setModalVisible(true)
                     setEventelements(null)
                     let result = await api.get('api/event/' + node.id)
                     setEventelements(result)
                 }
             })
-            .style('cursor', filter.type == AUTOCAPTURE ? 'pointer' : 'auto')
+            .style('cursor', filter.path_type == AUTOCAPTURE ? 'pointer' : 'auto')
 
         textSelection
             .append('tspan')
@@ -210,7 +210,9 @@ export function Paths() {
 
     return (
         <div>
-            {filter.type == AUTOCAPTURE && <div style={{ margin: 10 }}>Click on a tag to see related DOM tree</div>}
+            {filter.path_type == AUTOCAPTURE && (
+                <div style={{ margin: 10 }}>Click on a tag to see related DOM tree</div>
+            )}
             <div ref={canvas} className="paths" style={{ height: '90vh' }} data-attr="paths-viz">
                 {!pathsLoading && paths && paths.nodes.length === 0 ? (
                     <NoData />
diff --git a/frontend/src/scenes/paths/pathsLogic.js b/frontend/src/scenes/paths/pathsLogic.js
index 1231abff53ca8..7c56c6d411784 100644
--- a/frontend/src/scenes/paths/pathsLogic.js
+++ b/frontend/src/scenes/paths/pathsLogic.js
@@ -35,8 +35,8 @@ function checkRoot(nodeToVerify, paths, start) {
 
 function cleanPathParams(filters, properties) {
     return {
-        start: filters.start,
-        type: filters.type,
+        start_point: filters.start_point,
+        path_type: filters.path_type,
         date_from: filters.date_from,
         date_to: filters.date_to,
         properties: properties,
@@ -53,12 +53,12 @@ export const pathsLogic = kea({
             },
             loadPaths: async (_, breakpoint) => {
                 const params = toParams({ ...values.filter, properties: values.properties })
-                let paths = await api.get(`api/paths${params ? `/?${params}` : ''}`)
-                if (values.filter.start) {
+                let paths = await api.get(`api/insight/path${params ? `/?${params}` : ''}`)
+                if (values.filter.start_point) {
                     paths = paths.filter((checkingNode) => {
                         return (
-                            checkingNode.source.includes(values.filter.start) ||
-                            checkRoot(checkingNode, paths, values.filter.start)
+                            checkingNode.source.includes(values.filter.start_point) ||
+                            checkRoot(checkingNode, paths, values.filter.start_point)
                         )
                     })
                 }
@@ -81,7 +81,7 @@ export const pathsLogic = kea({
         initialPathname: [(state) => router.selectors.location(state).pathname, { noop: (a) => a }],
         filter: [
             {
-                type: '$pageview',
+                path_type: '$pageview',
             },
             {
                 setFilter: (state, filter) => ({ ...state, ...filter }),
@@ -106,8 +106,8 @@ export const pathsLogic = kea({
         },
         setFilter: () => {
             if (
-                values.filter.type !== AUTOCAPTURE ||
-                (values.filter.type === AUTOCAPTURE && !isNaN(values.filter.start))
+                values.filter.path_type !== AUTOCAPTURE ||
+                (values.filter.path_type === AUTOCAPTURE && !isNaN(values.filter.start_point))
             )
                 actions.loadPaths()
 
diff --git a/frontend/src/scenes/sessions/sessionsTableLogic.js b/frontend/src/scenes/sessions/sessionsTableLogic.js
index b64f9a6b580f4..7092a0f6f1604 100644
--- a/frontend/src/scenes/sessions/sessionsTableLogic.js
+++ b/frontend/src/scenes/sessions/sessionsTableLogic.js
@@ -9,7 +9,7 @@ export const sessionsTableLogic = kea({
             __default: [],
             loadSessions: async (selectedDate) => {
                 const response = await api.get(
-                    'api/event/sessions' + (selectedDate ? '/?date_from=' + values.selectedDateURLparam : '')
+                    'api/insight/session' + (selectedDate ? '/?date_from=' + values.selectedDateURLparam : '')
                 )
                 if (response.offset) actions.setOffset(response.offset)
                 if (response.date_from) actions.setDate(moment(response.date_from).startOf('day'))
@@ -43,7 +43,7 @@ export const sessionsTableLogic = kea({
     listeners: ({ values, actions }) => ({
         fetchNextSessions: async () => {
             const response = await api.get(
-                'api/event/sessions/?' + toParams({ date_from: values.selectedDateURLparam, offset: values.offset })
+                'api/insight/session/?' + toParams({ date_from: values.selectedDateURLparam, offset: values.offset })
             )
             if (response.offset) actions.setOffset(response.offset)
             else actions.setOffset(null)
diff --git a/posthog/api/__init__.py b/posthog/api/__init__.py
index fa18bfb2d0f34..325abbda6077b 100644
--- a/posthog/api/__init__.py
+++ b/posthog/api/__init__.py
@@ -9,6 +9,7 @@
     event,
     feature_flag,
     funnel,
+    insight,
     paths,
     person,
     personal_api_key,
@@ -29,3 +30,4 @@
 router.register(r"paths", paths.PathsViewSet, basename="paths")
 router.register(r"personal_api_keys", personal_api_key.PersonalAPIKeyViewSet, basename="personal_api_keys")
 router.register(r"team/user", team_user.TeamUserViewSet)
+router.register(r"insight", insight.InsightViewSet)
diff --git a/posthog/api/event.py b/posthog/api/event.py
index d595b527f701b..82946237e6dfd 100644
--- a/posthog/api/event.py
+++ b/posthog/api/event.py
@@ -12,6 +12,7 @@
 from rest_framework import exceptions, request, response, serializers, viewsets
 from rest_framework.decorators import action
 
+from posthog.constants import DATE_FROM, OFFSET
 from posthog.models import (
     Action,
     Element,
@@ -269,20 +270,15 @@ def values(self, request: request.Request) -> response.Response:
     @action(methods=["GET"], detail=False)
     def sessions(self, request: request.Request) -> response.Response:
         team = self.request.user.team_set.get()
-        session_type = self.request.GET.get("session")
 
         filter = Filter(request=request)
-        result: Dict[str, Any] = {
-            "result": Sessions().run(
-                filter, team, session_type=self.request.GET.get("session"), offset=self.request.GET.get("offset")
-            )
-        }
+        result: Dict[str, Any] = {"result": Sessions().run(filter, team)}
 
         # add pagination
-        if session_type is None:
-            offset = int(request.GET.get("offset", "0")) + 50
+        if filter.session_type is None:
+            offset = filter.offset + 50
             if len(result["result"]) > 49:
                 date_from = result["result"][0]["start_time"].isoformat()
-                result.update({"offset": offset})
-                result.update({"date_from": date_from})
+                result.update({OFFSET: offset})
+                result.update({DATE_FROM: date_from})
         return response.Response(result)
diff --git a/posthog/api/insight.py b/posthog/api/insight.py
new file mode 100644
index 0000000000000..5cb1c9b7bde4c
--- /dev/null
+++ b/posthog/api/insight.py
@@ -0,0 +1,237 @@
+from datetime import datetime
+from distutils.util import strtobool
+from typing import Any, Dict, List
+
+from django.core.cache import cache
+from django.db.models import QuerySet
+from django.utils.timezone import now
+from rest_framework import request, serializers, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from posthog.celery import update_cache_item_task
+from posthog.constants import DATE_FROM, FROM_DASHBOARD, INSIGHT, OFFSET, TRENDS_STICKINESS
+from posthog.decorators import FUNNEL_ENDPOINT, TRENDS_ENDPOINT, cached_function
+from posthog.models import DashboardItem, Filter
+from posthog.queries import paths, retention, sessions, stickiness, trends
+from posthog.utils import generate_cache_key, request_to_date_query
+
+
+class InsightSerializer(serializers.ModelSerializer):
+    result = serializers.SerializerMethodField()
+
+    class Meta:
+        model = DashboardItem
+        fields = [
+            "id",
+            "name",
+            "filters",
+            "order",
+            "type",
+            "deleted",
+            "dashboard",
+            "layouts",
+            "color",
+            "last_refresh",
+            "refreshing",
+            "result",
+            "created_at",
+            "saved",
+            "created_by",
+        ]
+
+    def create(self, validated_data: Dict, *args: Any, **kwargs: Any) -> DashboardItem:
+
+        request = self.context["request"]
+        team = request.user.team_set.get()
+        validated_data.pop("last_refresh", None)  # last_refresh sometimes gets sent if dashboard_item is duplicated
+
+        if not validated_data.get("dashboard", None):
+            dashboard_item = DashboardItem.objects.create(team=team, created_by=request.user, **validated_data)
+            return dashboard_item
+        elif validated_data["dashboard"].team == team:
+            filter_data = validated_data.pop("filters", None)
+            filters = Filter(data=filter_data) if filter_data else None
+            dashboard_item = DashboardItem.objects.create(
+                team=team, last_refresh=now(), filters=filters.to_dict() if filters else {}, **validated_data
+            )
+            return dashboard_item
+        else:
+            raise serializers.ValidationError("Dashboard not found")
+
+    def get_result(self, dashboard_item: DashboardItem):
+        if not dashboard_item.filters:
+            return None
+        filter = Filter(data=dashboard_item.filters)
+        cache_key = generate_cache_key(filter.toJSON() + "_" + str(dashboard_item.team_id))
+        result = cache.get(cache_key)
+        if not result or result.get("task_id", None):
+            return None
+        return result["result"]
+
+
+class InsightViewSet(viewsets.ModelViewSet):
+    queryset = DashboardItem.objects.all()
+    serializer_class = InsightSerializer
+
+    def get_queryset(self) -> QuerySet:
+        queryset = super().get_queryset()
+        if self.action == "list":  # type: ignore
+            queryset = queryset.filter(deleted=False)
+            queryset = self._filter_request(self.request, queryset)
+
+        order = self.request.GET.get("order", None)
+        if order:
+            queryset = queryset.order_by(order)
+        else:
+            queryset = queryset.order_by("order")
+
+        return queryset.filter(team=self.request.user.team_set.get())
+
+    def _filter_request(self, request: request.Request, queryset: QuerySet) -> QuerySet:
+        filters = request.GET.dict()
+
+        for key in filters:
+            if key == "saved":
+                queryset = queryset.filter(saved=bool(strtobool(str(request.GET["saved"]))))
+            elif key == "user":
+                queryset = queryset.filter(created_by=request.user)
+            elif key == INSIGHT:
+                queryset = queryset.filter(filters__insight=request.GET[INSIGHT])
+
+        return queryset
+
+    # ******************************************
+    # Calculated Insight Endpoints
+    # /insight/trend
+    # /insight/session
+    # /insight/funnel
+    # /insight/retention
+    # /insight/path
+    #
+    # Request parameteres and caching are handled here and passed onto respective .queries classes
+    # ******************************************
+
+    # ******************************************
+    # /insight/trend
+    #
+    # params:
+    # - from_dashboard: (string) determines trend is being retrieved from dashboard item to update dashboard_item metadata
+    # - shown_as: (string: Volume, Stickiness) specifies the trend aggregation type
+    # - **shared filter types
+    # ******************************************
+    @action(methods=["GET"], detail=False)
+    def trend(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
+        result = self._calculate_trends(request)
+        return Response(result)
+
+    @cached_function(cache_type=TRENDS_ENDPOINT)
+    def _calculate_trends(self, request: request.Request) -> List[Dict[str, Any]]:
+        team = request.user.team_set.get()
+        filter = Filter(request=request)
+        if filter.shown_as == TRENDS_STICKINESS:
+            result = stickiness.Stickiness().run(filter, team)
+        else:
+            result = trends.Trends().run(filter, team)
+
+        self._refresh_dashboard(request=request)
+
+        return result
+
+    # ******************************************
+    # /insight/session
+    #
+    # params:
+    # - session: (string: avg, dist) specifies session type
+    # - offset: (number) offset query param for paginated list of user sessions
+    # - **shared filter types
+    # ******************************************
+    @action(methods=["GET"], detail=False)
+    def session(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
+        team = self.request.user.team_set.get()
+
+        filter = Filter(request=request)
+        result: Dict[str, Any] = {"result": sessions.Sessions().run(filter, team)}
+
+        # add pagination
+        if filter.session_type is None:
+            offset = filter.offset + 50
+            if len(result["result"]) > 49:
+                date_from = result["result"][0]["start_time"].isoformat()
+                result.update({OFFSET: offset})
+                result.update({DATE_FROM: date_from})
+        return Response(result)
+
+    # ******************************************
+    # /insight/funnel
+    # The funnel endpoint is asynchronously processed. When a request is received, the endpoint will
+    # call an async task with an id that can be continually polled for 3 minutes.
+    #
+    # params:
+    # - refresh: (dict) specifies cache to force refresh or poll
+    # - from_dashboard: (dict) determines funnel is being retrieved from dashboard item to update dashboard_item metadata
+    # - **shared filter types
+    # ******************************************
+    @action(methods=["GET"], detail=False)
+    def funnel(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
+        team = request.user.team_set.get()
+        refresh = request.GET.get("refresh", None)
+
+        filter = Filter(request=request)
+        cache_key = generate_cache_key("{}_{}".format(filter.toJSON(), team.pk))
+        result = {"loading": True}
+
+        if refresh:
+            cache.delete(cache_key)
+        else:
+            cached_result = cache.get(cache_key)
+            if cached_result:
+                task_id = cached_result.get("task_id", None)
+                if not task_id:
+                    return Response(cached_result["result"])
+                else:
+                    return Response(result)
+
+        payload = {"filter": filter.toJSON(), "team_id": team.pk}
+
+        task = update_cache_item_task.delay(cache_key, FUNNEL_ENDPOINT, payload)
+        task_id = task.id
+        cache.set(cache_key, {"task_id": task_id}, 180)  # task will be live for 3 minutes
+
+        self._refresh_dashboard(request=request)
+
+        return Response(result)
+
+    # ******************************************
+    # /insight/retention
+    # params:
+    # - start_entity: (dict) specifies id and type of the entity to focus retention on
+    # - **shared filter types
+    # ******************************************
+    @action(methods=["GET"], detail=False)
+    def retention(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
+        team = request.user.team_set.get()
+        filter = Filter(request=request)
+        filter._date_from = "-11d"
+        result = retention.Retention().run(filter, team)
+        return Response({"data": result})
+
+    # ******************************************
+    # /insight/path
+    # params:
+    # - start: (string) specifies the name of the starting property or element
+    # - request_type: (string: $pageview, $autocapture, $screen, custom_event) specifies the path type
+    # - **shared filter types
+    # ******************************************
+    @action(methods=["GET"], detail=False)
+    def path(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
+        team = request.user.team_set.get()
+        filter = Filter(request=request)
+        resp = paths.Paths().run(filter=filter, team=team)
+        return Response(resp)
+
+    # Checks if a dashboard id has been set and if so, update the refresh date
+    def _refresh_dashboard(self, request) -> None:
+        dashboard_id = request.GET.get(FROM_DASHBOARD, None)
+        if dashboard_id:
+            DashboardItem.objects.filter(pk=dashboard_id).update(last_refresh=datetime.now())
diff --git a/posthog/api/paths.py b/posthog/api/paths.py
index 5a0a9b22e2b12..b46c245d482d0 100644
--- a/posthog/api/paths.py
+++ b/posthog/api/paths.py
@@ -1,52 +1,16 @@
-import json
-from typing import Optional
-
 from django.db import connection
-from django.db.models import F, OuterRef, Q
-from django.db.models.expressions import Window
-from django.db.models.functions import Lag
 from rest_framework import request, viewsets
 from rest_framework.decorators import action
 from rest_framework.response import Response
 
 from posthog.models import Event, Filter
+from posthog.queries import paths
 from posthog.utils import dict_from_cursor_fetchall, request_to_date_query
 
 
 # At the moment, paths don't support users changing distinct_ids midway through.
 # See: https://github.com/PostHog/posthog/issues/185
 class PathsViewSet(viewsets.ViewSet):
-    def _event_subquery(self, event: str, key: str):
-        return Event.objects.filter(pk=OuterRef(event)).values(key)[:1]
-
-    def _determine_path_type(self, request):
-        requested_type = request.GET.get("type", None)
-
-        # Default
-        event: Optional[str] = "$pageview"
-        event_filter = {"event": event}
-        path_type = "properties->> '$current_url'"
-        start_comparator = "{} ~".format(path_type)
-
-        # determine requested type
-        if requested_type:
-            if requested_type == "$screen":
-                event = "$screen"
-                event_filter = {"event": event}
-                path_type = "properties->> '$screen_name'"
-                start_comparator = "{} ~".format(path_type)
-            elif requested_type == "$autocapture":
-                event = "$autocapture"
-                event_filter = {"event": event}
-                path_type = "tag_name_source"
-                start_comparator = "group_id ="
-            elif requested_type == "custom_event":
-                event = None
-                event_filter = {}
-                path_type = "event"
-                start_comparator = "event ="
-        return event, path_type, event_filter, start_comparator
-
     @action(methods=["GET"], detail=False)
     def elements(self, request: request.Request):
 
@@ -66,133 +30,15 @@ def elements(self, request: request.Request):
         rows = dict_from_cursor_fetchall(cursor)
         return Response(rows)
 
-    def _apply_start_point(self, start_comparator: str, query_string: str, start_point: str) -> str:
-        marked = "\
-            SELECT *, CASE WHEN {} '{}' THEN timestamp ELSE NULL END as mark from ({}) as sessionified\
-        ".format(
-            start_comparator, start_point, query_string
-        )
-
-        marked_plus = "\
-            SELECT *, MIN(mark) OVER (\
-                    PARTITION BY distinct_id\
-                    , session ORDER BY timestamp\
-                    ) AS max from ({}) as marked order by session\
-        ".format(
-            marked
-        )
-
-        sessionified = "\
-            SELECT * FROM ({}) as something where timestamp >= max \
-        ".format(
-            marked_plus
-        )
-        return sessionified
-
-    def _add_elements(self, query_string: str) -> str:
-        element = 'SELECT \'<\'|| e."tag_name" || \'> \'  || e."text" as tag_name_source, e."text" as text_source FROM "posthog_element" e JOIN \
-                    ( SELECT group_id, MIN("posthog_element"."order") as minOrder FROM "posthog_element" GROUP BY group_id) e2 ON e.order = e2.minOrder AND e.group_id = e2.group_id where e.group_id = v2.group_id'
-        element_group = 'SELECT g."id" as group_id FROM "posthog_elementgroup" g where v1."elements_hash" = g."hash"'
-        sessions_sql = "SELECT * FROM ({}) as v1 JOIN LATERAL ({}) as v2 on true JOIN LATERAL ({}) as v3 on true".format(
-            query_string, element_group, element
-        )
-        return sessions_sql
-
     # FIXME: Timestamp is timezone aware timestamp, date range uses naive date.
     # To avoid unexpected results should convert date range to timestamps with timezone.
     def list(self, request):
         team = request.user.team_set.get()
-        resp = []
         date_query = request_to_date_query(request.GET, exact=False)
-        event, path_type, event_filter, start_comparator = self._determine_path_type(request)
-        properties = request.GET.get("properties")
+        filter = Filter(request=request)
         start_point = request.GET.get("start")
-
-        sessions = (
-            Event.objects.add_person_id(team.pk)
-            .filter(team=team, **(event_filter), **date_query)
-            .filter(~Q(event__in=["$autocapture", "$pageview", "$identify", "$pageleave"]) if event is None else Q())
-            .filter(
-                Filter(data={"properties": json.loads(properties)}).properties_to_Q(team_id=team.pk)
-                if properties
-                else Q()
-            )
-            .annotate(
-                previous_timestamp=Window(
-                    expression=Lag("timestamp", default=None),
-                    partition_by=F("distinct_id"),
-                    order_by=F("timestamp").asc(),
-                )
-            )
-        )
-
-        sessions_sql, sessions_sql_params = sessions.query.sql_with_params()
-
-        if event == "$autocapture":
-            sessions_sql = self._add_elements(query_string=sessions_sql)
-
-        events_notated = "\
-        SELECT *, CASE WHEN EXTRACT('EPOCH' FROM (timestamp - previous_timestamp)) >= (60 * 30) OR previous_timestamp IS NULL THEN 1 ELSE 0 END AS new_session\
-        FROM ({}) AS inner_sessions\
-        ".format(
-            sessions_sql
-        )
-
-        sessionified = "\
-        SELECT events_notated.*, SUM(new_session) OVER (\
-            ORDER BY distinct_id\
-                    ,timestamp\
-            ) AS session\
-        FROM ({}) as events_notated\
-        ".format(
-            events_notated
-        )
-
-        if start_point:
-            sessionified = self._apply_start_point(
-                start_comparator=start_comparator, query_string=sessionified, start_point=start_point,
-            )
-
-        final = "\
-        SELECT {} as path_type, id, sessionified.session\
-            ,ROW_NUMBER() OVER (\
-                    PARTITION BY distinct_id\
-                    ,session ORDER BY timestamp\
-                    ) AS event_number\
-        FROM ({}) as sessionified\
-        ".format(
-            path_type, sessionified
+        request_type = request.GET.get("type", None)
+        resp = paths.Paths().run(
+            filter=filter, start_point=start_point, date_query=date_query, request_type=request_type, team=team
         )
-
-        counts = "\
-        SELECT event_number || '_' || path_type as target_event, id as target_id, LAG(event_number || '_' || path_type, 1) OVER (\
-            PARTITION BY session\
-            ) AS source_event , LAG(id, 1) OVER (\
-            PARTITION BY session\
-            ) AS source_id from \
-        ({}) as final\
-        where event_number <= 4\
-        ".format(
-            final
-        )
-
-        cursor = connection.cursor()
-        cursor.execute(
-            "\
-        SELECT source_event, target_event, MAX(target_id), MAX(source_id), count(*) from ({}) as counts\
-        where source_event is not null and target_event is not null\
-        group by source_event, target_event order by count desc limit 20\
-        ".format(
-                counts
-            ),
-            sessions_sql_params,
-        )
-        rows = cursor.fetchall()
-
-        for row in rows:
-            resp.append(
-                {"source": row[0], "target": row[1], "target_id": row[2], "source_id": row[3], "value": row[4],}
-            )
-
-        resp = sorted(resp, key=lambda x: x["value"], reverse=True)
         return Response(resp)
diff --git a/posthog/api/test/test_event.py b/posthog/api/test/test_event.py
index 6e0adb0e3e197..7c1901bc1f970 100644
--- a/posthog/api/test/test_event.py
+++ b/posthog/api/test/test_event.py
@@ -231,173 +231,6 @@ def test_before_and_after(self):
         self.assertEqual(len(response["results"]), 1)
         self.assertEqual(response["results"][0]["id"], event2.pk)
 
-    def test_sessions_list(self):
-        with freeze_time("2012-01-14T03:21:34.000Z"):
-            Event.objects.create(team=self.team, event="1st action", distinct_id="1")
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-        with freeze_time("2012-01-14T03:25:34.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="2")
-        with freeze_time("2012-01-15T03:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-15T04:01:34.000Z"):
-            Event.objects.create(team=self.team, event="4th action", distinct_id="1")
-            Event.objects.create(team=self.team, event="4th action", distinct_id="2")
-
-        with freeze_time("2012-01-15T04:01:34.000Z"):
-            response = self.client.get("/api/event/sessions/").json()
-        self.assertEqual(len(response["result"]), 2)
-        self.assertEqual(response["result"][0]["global_session_id"], 1)
-
-    def test_sessions_avg_length(self):
-        with freeze_time("2012-01-14T03:21:34.000Z"):
-            Event.objects.create(team=self.team, event="1st action", distinct_id="1")
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-        with freeze_time("2012-01-14T03:25:34.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="2")
-        with freeze_time("2012-01-15T03:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-15T04:01:34.000Z"):
-            Event.objects.create(team=self.team, event="4th action", distinct_id="1")
-            Event.objects.create(team=self.team, event="4th action", distinct_id="2")
-
-        response = self.client.get("/api/event/sessions/?session=avg&date_from=all").json()
-        self.assertEqual(response["result"][0]["count"], 3)  # average length of all sessions
-
-        # time series
-        self.assertEqual(response["result"][0]["data"][0], 240)
-        self.assertEqual(response["result"][0]["data"][1], 120)
-        self.assertEqual(response["result"][0]["labels"][0], "Sat. 14 January")
-        self.assertEqual(response["result"][0]["labels"][1], "Sun. 15 January")
-        self.assertEqual(response["result"][0]["days"][0], "2012-01-14")
-        self.assertEqual(response["result"][0]["days"][1], "2012-01-15")
-
-    def test_sessions_avg_length_interval(self):
-        with freeze_time("2012-01-14T03:21:34.000Z"):
-            Event.objects.create(team=self.team, event="1st action", distinct_id="1")
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-        with freeze_time("2012-01-14T03:25:34.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="2")
-        with freeze_time("2012-01-25T03:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-25T04:01:34.000Z"):
-            Event.objects.create(team=self.team, event="4th action", distinct_id="1")
-            Event.objects.create(team=self.team, event="4th action", distinct_id="2")
-
-        with freeze_time("2012-03-14T03:21:34.000Z"):
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-        with freeze_time("2012-03-14T03:25:34.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="2")
-        with freeze_time("2012-03-15T03:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-03-15T04:01:34.000Z"):
-            Event.objects.create(team=self.team, event="4th action", distinct_id="2")
-
-        # month
-        month_response = self.client.get(
-            "/api/event/sessions/?session=avg&date_from=2012-01-01&date_to=2012-04-01&interval=month"
-        ).json()
-        self.assertEqual(month_response["result"][0]["data"][0], 180)
-        self.assertEqual(month_response["result"][0]["data"][2], 180)
-        self.assertEqual(month_response["result"][0]["labels"][0], "Tue. 31 January")
-        self.assertEqual(month_response["result"][0]["labels"][1], "Wed. 29 February")
-        self.assertEqual(month_response["result"][0]["days"][0], "2012-01-31")
-        self.assertEqual(month_response["result"][0]["days"][1], "2012-02-29")
-
-        # # week
-        week_response = self.client.get(
-            "/api/event/sessions/?session=avg&date_from=2012-01-01&date_to=2012-02-01&interval=week"
-        ).json()
-        self.assertEqual(week_response["result"][0]["data"][1], 240.0)
-        self.assertEqual(week_response["result"][0]["data"][3], 120.0)
-        self.assertEqual(week_response["result"][0]["labels"][0], "Sun. 1 January")
-        self.assertEqual(week_response["result"][0]["labels"][1], "Sun. 8 January")
-        self.assertEqual(week_response["result"][0]["days"][0], "2012-01-01")
-        self.assertEqual(week_response["result"][0]["days"][1], "2012-01-08")
-
-        # # # hour
-        hour_response = self.client.get(
-            "/api/event/sessions/?session=avg&date_from=2012-03-14&date_to=2012-03-16&interval=hour"
-        ).json()
-        self.assertEqual(hour_response["result"][0]["data"][3], 240.0)
-        self.assertEqual(hour_response["result"][0]["data"][27], 120.0)
-        self.assertEqual(hour_response["result"][0]["labels"][0], "Wed. 14 March, 00:00")
-        self.assertEqual(hour_response["result"][0]["labels"][1], "Wed. 14 March, 01:00")
-        self.assertEqual(hour_response["result"][0]["days"][0], "2012-03-14 00:00:00")
-        self.assertEqual(hour_response["result"][0]["days"][1], "2012-03-14 01:00:00")
-
-    def test_sessions_count_buckets(self):
-
-        # 0 seconds
-        with freeze_time("2012-01-11T01:25:30.000Z"):
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
-            Event.objects.create(team=self.team, event="1st action", distinct_id="4")
-        with freeze_time("2012-01-11T01:25:32.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="4")  # within 0-3 seconds
-            Event.objects.create(team=self.team, event="1st action", distinct_id="6")
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="7")
-        with freeze_time("2012-01-11T01:25:40.000Z"):
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="6")  # within 3-10 seconds
-            Event.objects.create(team=self.team, event="2nd action", distinct_id="7")  # within 3-10 seconds
-
-        with freeze_time("2012-01-15T04:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="4")
-        with freeze_time("2012-01-15T05:00:00.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")  # within 10-30 seconds
-        with freeze_time("2012-01-15T05:00:20.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="4")  # within 30-60 seconds
-
-        # within 1-3 mins
-        with freeze_time("2012-01-17T04:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="5")
-        with freeze_time("2012-01-17T05:01:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
-        with freeze_time("2012-01-17T05:07:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")  # test many events within a range
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")  # within 3-10 mins
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="10")
-
-        with freeze_time("2012-01-17T05:20:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="5")  # within 10-30 mins
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="9")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="10")
-        with freeze_time("2012-01-17T05:40:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="9")
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="10")  # within 30-60 mins
-        with freeze_time("2012-01-17T05:58:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="9")  # -> within 30-60 mins
-
-        # within 1+ hours
-        with freeze_time("2012-01-21T04:59:34.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-21T05:20:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-21T05:45:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-        with freeze_time("2012-01-21T06:00:30.000Z"):
-            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
-
-        response = self.client.get("/api/event/sessions/?session=dist&date_from=all").json()
-        compared_response = self.client.get("/api/event/sessions/?session=dist&date_from=all&compare=true").json()
-        for index, item in enumerate(response["result"]):
-            if item["label"] == "30-60 minutes" or item["label"] == "3-10 seconds":
-                self.assertEqual(item["count"], 2)
-                self.assertEqual(compared_response["result"][index]["count"], 2)
-            else:
-                self.assertEqual(item["count"], 1)
-                self.assertEqual(compared_response["result"][index]["count"], 1)
-
     def test_pagination(self):
         events = []
         for index in range(0, 150):
diff --git a/posthog/api/test/test_insight.py b/posthog/api/test/test_insight.py
new file mode 100644
index 0000000000000..25192944acc69
--- /dev/null
+++ b/posthog/api/test/test_insight.py
@@ -0,0 +1,138 @@
+import json
+from datetime import datetime, timedelta
+
+from django.test.utils import override_settings
+from freezegun import freeze_time
+
+from posthog.models.dashboard_item import DashboardItem
+from posthog.models.event import Event
+from posthog.models.filter import Filter
+from posthog.models.person import Person
+
+from .base import TransactionBaseTest
+
+
+class TestInsightApi(TransactionBaseTest):
+    TESTS_API = True
+
+    def test_get_insight_items(self):
+
+        filter_dict = {
+            "events": [{"id": "$pageview"}],
+            "properties": [{"key": "$browser", "value": "Mac OS X"}],
+        }
+
+        DashboardItem.objects.create(filters=Filter(data=filter_dict).to_dict(), team=self.team, created_by=self.user)
+
+        # create without user
+        DashboardItem.objects.create(filters=Filter(data=filter_dict).to_dict(), team=self.team)
+
+        response = self.client.get("/api/insight/", data={"user": "true"}).json()
+
+        self.assertEqual(len(response["results"]), 1)
+
+    def test_get_saved_insight_items(self):
+
+        filter_dict = {
+            "events": [{"id": "$pageview"}],
+            "properties": [{"key": "$browser", "value": "Mac OS X"}],
+        }
+
+        DashboardItem.objects.create(
+            filters=Filter(data=filter_dict).to_dict(), saved=True, team=self.team, created_by=self.user
+        )
+
+        # create without saved
+        DashboardItem.objects.create(filters=Filter(data=filter_dict).to_dict(), team=self.team, created_by=self.user)
+
+        # create without user
+        DashboardItem.objects.create(filters=Filter(data=filter_dict).to_dict(), team=self.team)
+
+        response = self.client.get("/api/insight/", data={"saved": "true", "user": "true",},).json()
+
+        self.assertEqual(len(response["results"]), 1)
+
+    def test_create_insight_items(self):
+
+        self.client.post(
+            "/api/insight/",
+            data={
+                "filters": {"events": [{"id": "$pageview"}], "properties": [{"key": "$browser", "value": "Mac OS X"}],},
+            },
+            content_type="application/json",
+        ).json()
+
+        response = DashboardItem.objects.all()
+        self.assertEqual(len(response), 1)
+        self.assertListEqual(response[0].filters["events"], [{"id": "$pageview"}])
+
+    # BASIC TESTING OF ENDPOINTS. /queries as in depth testing for each insight
+
+    def test_insight_trends_basic(self):
+        with freeze_time("2012-01-14T03:21:34.000Z"):
+            Event.objects.create(team=self.team, event="$pageview", distinct_id="1")
+            Event.objects.create(team=self.team, event="$pageview", distinct_id="2")
+
+        with freeze_time("2012-01-15T04:01:34.000Z"):
+            response = self.client.get("/api/insight/trend/?events={}".format(json.dumps([{"id": "$pageview"}]))).json()
+
+        self.assertEqual(response[0]["count"], 2)
+        self.assertEqual(response[0]["action"]["name"], "$pageview")
+
+    def test_insight_session_basic(self):
+        with freeze_time("2012-01-14T03:21:34.000Z"):
+            Event.objects.create(team=self.team, event="1st action", distinct_id="1")
+            Event.objects.create(team=self.team, event="1st action", distinct_id="2")
+        with freeze_time("2012-01-14T03:25:34.000Z"):
+            Event.objects.create(team=self.team, event="2nd action", distinct_id="1")
+            Event.objects.create(team=self.team, event="2nd action", distinct_id="2")
+        with freeze_time("2012-01-15T03:59:34.000Z"):
+            Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
+        with freeze_time("2012-01-15T03:59:35.000Z"):
+            Event.objects.create(team=self.team, event="3rd action", distinct_id="1")
+        with freeze_time("2012-01-15T04:01:34.000Z"):
+            Event.objects.create(team=self.team, event="4th action", distinct_id="1", properties={"$os": "Mac OS X"})
+            Event.objects.create(team=self.team, event="4th action", distinct_id="2", properties={"$os": "Windows 95"})
+
+        with freeze_time("2012-01-15T04:01:34.000Z"):
+            response = self.client.get("/api/insight/session/",).json()
+
+        self.assertEqual(len(response["result"]), 2)
+
+    @override_settings(CELERY_TASK_ALWAYS_EAGER=True)
+    def test_insight_funnels_basic(self):
+        Event.objects.create(team=self.team, event="user signed up")
+        response = self.client.get(
+            "/api/insight/funnel/?events={}".format(
+                json.dumps([{"id": "user signed up", "type": "events", "order": 0},])
+            )
+        ).json()
+        self.assertEqual(response["loading"], True)
+
+    def test_insight_retention_basic(self):
+        person1 = Person.objects.create(
+            team=self.team, distinct_ids=["person1"], properties={"email": "person1@test.com"}
+        )
+        Event.objects.create(
+            team=self.team, event="$pageview", distinct_id="person1", timestamp=datetime.now() - timedelta(days=11)
+        )
+
+        Event.objects.create(
+            team=self.team, event="$pageview", distinct_id="person1", timestamp=datetime.now() - timedelta(days=10)
+        )
+        response = self.client.get("/api/insight/retention/",).json()
+
+        self.assertEqual(len(response["data"]), 11)
+        self.assertEqual(response["data"][0]["values"][0]["count"], 1)
+
+    def test_insight_paths_basic(self):
+        person1 = Person.objects.create(team=self.team, distinct_ids=["person_1"])
+        Event.objects.create(
+            properties={"$current_url": "/"}, distinct_id="person_1", event="$pageview", team=self.team,
+        )
+        Event.objects.create(
+            properties={"$current_url": "/about"}, distinct_id="person_1", event="$pageview", team=self.team,
+        )
+
+        response = self.client.get("/api/insight/path/",).json()
+        self.assertEqual(len(response), 1)
diff --git a/posthog/constants.py b/posthog/constants.py
index ee6f1ac21b517..49c8cd0137d41 100644
--- a/posthog/constants.py
+++ b/posthog/constants.py
@@ -1,3 +1,5 @@
+from enum import Enum
+
 TREND_FILTER_TYPE_ACTIONS = "actions"
 TREND_FILTER_TYPE_EVENTS = "events"
 
@@ -5,3 +7,33 @@
 TRENDS_LINEAR = "ActionsLineGraph"
 
 TRENDS_STICKINESS = "Stickiness"
+
+SESSION_AVG = "avg"
+SESSION_DIST = "dist"
+
+SCREEN_EVENT = "$screen"
+AUTOCAPTURE_EVENT = "$autocapture"
+PAGEVIEW_EVENT = "$pageview"
+CUSTOM_EVENT = "custom_event"
+
+
+DATE_FROM = "date_from"
+DATE_TO = "date_to"
+ENTITIES = "entities"
+ACTIONS = "actions"
+EVENTS = "events"
+PROPERTIES = "properties"
+SELECTOR = "selector"
+INTERVAL = "interval"
+DISPLAY = "display"
+SHOWN_AS = "shown_as"
+BREAKDOWN_TYPE = "breakdown_type"
+COMPARE = "compare"
+INSIGHT = "insight"
+SESSION = "session"
+BREAKDOWN = "breakdown"
+FROM_DASHBOARD = "from_dashboard"
+PATH_TYPE = "path_type"
+START_POINT = "start_point"
+TARGET_ENTITY = "target_entity"
+OFFSET = "offset"
diff --git a/posthog/models/event.py b/posthog/models/event.py
index 29d72ff7a4fe5..bbc9cee035099 100644
--- a/posthog/models/event.py
+++ b/posthog/models/event.py
@@ -231,10 +231,14 @@ def filter_by_event_with_people(self, event, team_id, order_by="-id") -> models.
             events = events.order_by(order_by)
         return events
 
-    def query_retention(self, filters, team, start_entity: Optional[Entity] = None) -> dict:
+    def query_retention(self, filters: Filter, team) -> dict:
 
         events: QuerySet = QuerySet()
-        entity = Entity({"id": "$pageview", "type": TREND_FILTER_TYPE_EVENTS}) if not start_entity else start_entity
+        entity = (
+            Entity({"id": "$pageview", "type": TREND_FILTER_TYPE_EVENTS})
+            if not filters.target_entity
+            else filters.target_entity
+        )
         if entity.type == TREND_FILTER_TYPE_EVENTS:
             events = Event.objects.filter_by_event_with_people(event=entity.id, team_id=team.id)
         elif entity.type == TREND_FILTER_TYPE_ACTIONS:
diff --git a/posthog/models/filter.py b/posthog/models/filter.py
index bdba20eb3b5b3..cea3b8b110066 100644
--- a/posthog/models/filter.py
+++ b/posthog/models/filter.py
@@ -8,7 +8,29 @@
 from django.http import HttpRequest
 from django.utils import timezone
 
-from posthog.constants import TREND_FILTER_TYPE_ACTIONS, TREND_FILTER_TYPE_EVENTS
+from posthog.constants import (
+    ACTIONS,
+    BREAKDOWN,
+    BREAKDOWN_TYPE,
+    COMPARE,
+    DATE_FROM,
+    DATE_TO,
+    DISPLAY,
+    ENTITIES,
+    EVENTS,
+    INSIGHT,
+    INTERVAL,
+    OFFSET,
+    PATH_TYPE,
+    PROPERTIES,
+    SELECTOR,
+    SESSION,
+    SHOWN_AS,
+    START_POINT,
+    TARGET_ENTITY,
+    TREND_FILTER_TYPE_ACTIONS,
+    TREND_FILTER_TYPE_EVENTS,
+)
 from posthog.utils import relative_date_parse
 
 from .entity import Entity
@@ -35,43 +57,53 @@ class Filter(PropertyMixin):
     _compare: Optional[Union[bool, str]] = None
     funnel_id: Optional[int] = None
     insight: Optional[str] = None
+    session_type: Optional[str] = None
+    path_type: Optional[str] = None
+    start_point: Optional[str] = None
+    target_entity: Optional[Entity] = None
+    _offset: Optional[str] = None
 
     def __init__(self, data: Optional[Dict[str, Any]] = None, request: Optional[HttpRequest] = None,) -> None:
         if request:
             data = {
                 **request.GET.dict(),
-                **({"properties": json.loads(request.GET["properties"])} if request.GET.get("properties") else {}),
-                "actions": json.loads(request.GET.get("actions", "[]")),
-                "events": json.loads(request.GET.get("events", "[]")),
+                **({PROPERTIES: json.loads(request.GET[PROPERTIES])} if request.GET.get(PROPERTIES) else {}),
+                ACTIONS: json.loads(request.GET.get(ACTIONS, "[]")),
+                EVENTS: json.loads(request.GET.get(EVENTS, "[]")),
             }
         elif not data:
             raise ValueError("You need to define either a data dict or a request")
-        self._date_from = data.get("date_from")
-        self._date_to = data.get("date_to")
-        self.entities = data.get("entities", [])
-        self.properties = self._parse_properties(data.get("properties"))
-        self.selector = data.get("selector", [])
-        self.interval = data.get("interval")
-        self.display = data.get("display")
-        self.selector = data.get("selector")
-        self.shown_as = data.get("shown_as")
+        self._date_from = data.get(DATE_FROM)
+        self._date_to = data.get(DATE_TO)
+        self.entities = data.get(ENTITIES, [])
+        self.properties = self._parse_properties(data.get(PROPERTIES))
+        self.selector = data.get(SELECTOR, [])
+        self.interval = data.get(INTERVAL)
+        self.display = data.get(DISPLAY)
+        self.selector = data.get(SELECTOR)
+        self.shown_as = data.get(SHOWN_AS)
         self.breakdown = self._parse_breakdown(data)
-        self.breakdown_type = data.get("breakdown_type")
-        self._compare = data.get("compare", "false")
-        self.insight = data.get("insight")
-
-        if data.get("actions"):
+        self.breakdown_type = data.get(BREAKDOWN_TYPE)
+        self._compare = data.get(COMPARE, "false")
+        self.insight = data.get(INSIGHT)
+        self.session_type = data.get(SESSION)
+        self.path_type = data.get(PATH_TYPE)
+        self.start_point = data.get(START_POINT)
+        self.target_entity = self._parse_target_entity(data.get(TARGET_ENTITY))
+        self._offset = data.get(OFFSET)
+
+        if data.get(ACTIONS):
             self.entities.extend(
-                [Entity({**entity, "type": TREND_FILTER_TYPE_ACTIONS}) for entity in data.get("actions", [])]
+                [Entity({**entity, "type": TREND_FILTER_TYPE_ACTIONS}) for entity in data.get(ACTIONS, [])]
             )
-        if data.get("events"):
+        if data.get(EVENTS):
             self.entities.extend(
-                [Entity({**entity, "type": TREND_FILTER_TYPE_EVENTS}) for entity in data.get("events", [])]
+                [Entity({**entity, "type": TREND_FILTER_TYPE_EVENTS}) for entity in data.get(EVENTS, [])]
             )
         self.entities = sorted(self.entities, key=lambda entity: entity.order if entity.order else -1)
 
     def _parse_breakdown(self, data: Dict[str, Any]) -> Optional[Union[str, List[Union[str, int]]]]:
-        breakdown = data.get("breakdown")
+        breakdown = data.get(BREAKDOWN)
         if not isinstance(breakdown, str):
             return breakdown
         try:
@@ -79,21 +111,27 @@ def _parse_breakdown(self, data: Dict[str, Any]) -> Optional[Union[str, List[Uni
         except (TypeError, json.decoder.JSONDecodeError):
             return breakdown
 
+    def _parse_target_entity(self, target_entity_data) -> Optional[Entity]:
+        if target_entity_data:
+            data = json.loads(target_entity_data)
+            return Entity({"id": data["id"], "type": data["type"]})
+        return None
+
     def to_dict(self) -> Dict[str, Any]:
         full_dict = {
-            "date_from": self._date_from,
-            "date_to": self._date_to,
-            "properties": [prop.to_dict() for prop in self.properties],
-            "interval": self.interval,
-            "events": [entity.to_dict() for entity in self.events],
-            "actions": [entity.to_dict() for entity in self.actions],
-            "display": self.display,
-            "selector": self.selector,
-            "shown_as": self.shown_as,
-            "breakdown": self.breakdown,
-            "breakdown_type": self.breakdown_type,
-            "compare": self.compare,
-            "insight": self.insight,
+            DATE_FROM: self._date_from,
+            DATE_TO: self._date_to,
+            PROPERTIES: [prop.to_dict() for prop in self.properties],
+            INTERVAL: self.interval,
+            EVENTS: [entity.to_dict() for entity in self.events],
+            ACTIONS: [entity.to_dict() for entity in self.actions],
+            DISPLAY: self.display,
+            SELECTOR: self.selector,
+            SHOWN_AS: self.shown_as,
+            BREAKDOWN: self.breakdown,
+            BREAKDOWN_TYPE: self.breakdown_type,
+            COMPARE: self.compare,
+            INSIGHT: self.insight,
         }
         return {
             key: value
@@ -110,6 +148,10 @@ def compare(self) -> bool:
         else:
             return False
 
+    @property
+    def offset(self) -> int:
+        return int(self._offset or "0")
+
     @property
     def actions(self) -> List[Entity]:
         return [entity for entity in self.entities if entity.type == TREND_FILTER_TYPE_ACTIONS]
diff --git a/posthog/queries/base.py b/posthog/queries/base.py
index 168eb76a4dc66..d0713ae270bf4 100644
--- a/posthog/queries/base.py
+++ b/posthog/queries/base.py
@@ -4,7 +4,7 @@
 from dateutil.relativedelta import relativedelta
 from django.db.models import Q, QuerySet
 
-from posthog.constants import TREND_FILTER_TYPE_ACTIONS, TREND_FILTER_TYPE_EVENTS, TRENDS_CUMULATIVE, TRENDS_STICKINESS
+from posthog.constants import TREND_FILTER_TYPE_ACTIONS, TREND_FILTER_TYPE_EVENTS
 from posthog.models import Entity, Event, Filter, Team
 from posthog.utils import get_compare_period_dates
 
diff --git a/posthog/queries/paths.py b/posthog/queries/paths.py
new file mode 100644
index 0000000000000..63ad14d12104a
--- /dev/null
+++ b/posthog/queries/paths.py
@@ -0,0 +1,171 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from django.db import connection
+from django.db.models import F, OuterRef, Q
+from django.db.models.expressions import Window
+from django.db.models.functions import Lag
+
+from posthog.constants import AUTOCAPTURE_EVENT, CUSTOM_EVENT, SCREEN_EVENT
+from posthog.models import Event, Filter, Team
+from posthog.utils import relative_date_parse, request_to_date_query
+
+from .base import BaseQuery
+
+
+class Paths(BaseQuery):
+    def _event_subquery(self, event: str, key: str):
+        return Event.objects.filter(pk=OuterRef(event)).values(key)[:1]
+
+    def _determine_path_type(self, requested_type=None):
+        # Default
+        event: Optional[str] = "$pageview"
+        event_filter = {"event": event}
+        path_type = "properties->> '$current_url'"
+        start_comparator = "{} ~".format(path_type)
+
+        # determine requested type
+        if requested_type:
+            if requested_type == SCREEN_EVENT:
+                event = SCREEN_EVENT
+                event_filter = {"event": event}
+                path_type = "properties->> '$screen_name'"
+                start_comparator = "{} ~".format(path_type)
+            elif requested_type == AUTOCAPTURE_EVENT:
+                event = AUTOCAPTURE_EVENT
+                event_filter = {"event": event}
+                path_type = "tag_name_source"
+                start_comparator = "group_id ="
+            elif requested_type == CUSTOM_EVENT:
+                event = None
+                event_filter = {}
+                path_type = "event"
+                start_comparator = "event ="
+        return event, path_type, event_filter, start_comparator
+
+    def _apply_start_point(self, start_comparator: str, query_string: str, start_point: str) -> str:
+        marked = "\
+            SELECT *, CASE WHEN {} '{}' THEN timestamp ELSE NULL END as mark from ({}) as sessionified\
+        ".format(
+            start_comparator, start_point, query_string
+        )
+
+        marked_plus = "\
+            SELECT *, MIN(mark) OVER (\
+                    PARTITION BY distinct_id\
+                    , session ORDER BY timestamp\
+                    ) AS max from ({}) as marked order by session\
+        ".format(
+            marked
+        )
+
+        sessionified = "\
+            SELECT * FROM ({}) as something where timestamp >= max \
+        ".format(
+            marked_plus
+        )
+        return sessionified
+
+    def _add_elements(self, query_string: str) -> str:
+        element = 'SELECT \'<\'|| e."tag_name" || \'> \'  || e."text" as tag_name_source, e."text" as text_source FROM "posthog_element" e JOIN \
+                    ( SELECT group_id, MIN("posthog_element"."order") as minOrder FROM "posthog_element" GROUP BY group_id) e2 ON e.order = e2.minOrder AND e.group_id = e2.group_id where e.group_id = v2.group_id'
+        element_group = 'SELECT g."id" as group_id FROM "posthog_elementgroup" g where v1."elements_hash" = g."hash"'
+        sessions_sql = "SELECT * FROM ({}) as v1 JOIN LATERAL ({}) as v2 on true JOIN LATERAL ({}) as v3 on true".format(
+            query_string, element_group, element
+        )
+        return sessions_sql
+
+    def calculate_paths(self, filter: Filter, team: Team):
+        date_query = request_to_date_query({"date_from": filter._date_from, "date_to": filter._date_to}, exact=False)
+        resp = []
+        event, path_type, event_filter, start_comparator = self._determine_path_type(
+            filter.path_type if filter else None
+        )
+
+        sessions = (
+            Event.objects.add_person_id(team.pk)
+            .filter(team=team, **(event_filter), **date_query)
+            .filter(~Q(event__in=["$autocapture", "$pageview", "$identify", "$pageleave"]) if event is None else Q())
+            .filter(filter.properties_to_Q(team_id=team.pk) if filter and filter.properties else Q())
+            .annotate(
+                previous_timestamp=Window(
+                    expression=Lag("timestamp", default=None),
+                    partition_by=F("distinct_id"),
+                    order_by=F("timestamp").asc(),
+                )
+            )
+        )
+
+        sessions_sql, sessions_sql_params = sessions.query.sql_with_params()
+
+        if event == "$autocapture":
+            sessions_sql = self._add_elements(query_string=sessions_sql)
+
+        events_notated = "\
+        SELECT *, CASE WHEN EXTRACT('EPOCH' FROM (timestamp - previous_timestamp)) >= (60 * 30) OR previous_timestamp IS NULL THEN 1 ELSE 0 END AS new_session\
+        FROM ({}) AS inner_sessions\
+        ".format(
+            sessions_sql
+        )
+
+        sessionified = "\
+        SELECT events_notated.*, SUM(new_session) OVER (\
+            ORDER BY distinct_id\
+                    ,timestamp\
+            ) AS session\
+        FROM ({}) as events_notated\
+        ".format(
+            events_notated
+        )
+
+        if filter and filter.start_point:
+            sessionified = self._apply_start_point(
+                start_comparator=start_comparator, query_string=sessionified, start_point=filter.start_point,
+            )
+
+        final = "\
+        SELECT {} as path_type, id, sessionified.session\
+            ,ROW_NUMBER() OVER (\
+                    PARTITION BY distinct_id\
+                    ,session ORDER BY timestamp\
+                    ) AS event_number\
+        FROM ({}) as sessionified\
+        ".format(
+            path_type, sessionified
+        )
+
+        counts = "\
+        SELECT event_number || '_' || path_type as target_event, id as target_id, LAG(event_number || '_' || path_type, 1) OVER (\
+            PARTITION BY session\
+            ) AS source_event , LAG(id, 1) OVER (\
+            PARTITION BY session\
+            ) AS source_id from \
+        ({}) as final\
+        where event_number <= 4\
+        ".format(
+            final
+        )
+
+        cursor = connection.cursor()
+        cursor.execute(
+            "\
+        SELECT source_event, target_event, MAX(target_id), MAX(source_id), count(*) from ({}) as counts\
+        where source_event is not null and target_event is not null\
+        group by source_event, target_event order by count desc limit 20\
+        ".format(
+                counts
+            ),
+            sessions_sql_params,
+        )
+        rows = cursor.fetchall()
+
+        for row in rows:
+            resp.append(
+                {"source": row[0], "target": row[1], "target_id": row[2], "source_id": row[3], "value": row[4],}
+            )
+
+        resp = sorted(resp, key=lambda x: x["value"], reverse=True)
+        return resp
+
+    def run(self, filter: Filter, team: Team, *args, **kwargs) -> List[Dict[str, Any]]:
+        return self.calculate_paths(filter=filter, team=team)
diff --git a/posthog/queries/retention.py b/posthog/queries/retention.py
index 30e1d3e2d73e5..e10b597ae7865 100644
--- a/posthog/queries/retention.py
+++ b/posthog/queries/retention.py
@@ -1,17 +1,18 @@
 import datetime
 from datetime import timedelta
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
-from posthog.models import Entity, Event, Filter, Team
+from posthog.models import Event, Filter, Team
 from posthog.queries.base import BaseQuery
 
 
 class Retention(BaseQuery):
-    def calculate_retention(self, filter: Filter, team: Team, start_entity: Optional[Entity] = None, total_days=11):
+    def calculate_retention(self, filter: Filter, team: Team, total_days=11):
+
         date_from: datetime.datetime = filter.date_from  # type: ignore
         filter._date_to = (date_from + timedelta(days=total_days)).isoformat()
         labels_format = "%a. %-d %B"
-        resultset = Event.objects.query_retention(filter, team, start_entity=start_entity)
+        resultset = Event.objects.query_retention(filter, team)
 
         result = [
             {
@@ -27,9 +28,4 @@ def calculate_retention(self, filter: Filter, team: Team, start_entity: Optional
         return result
 
     def run(self, filter: Filter, team: Team, *args, **kwargs) -> List[Dict[str, Any]]:
-        return self.calculate_retention(
-            filter=filter,
-            team=team,
-            start_entity=filter.entities[0] if len(filter.entities) > 0 else None,
-            total_days=kwargs.get("total_days", 11),
-        )
+        return self.calculate_retention(filter=filter, team=team, total_days=kwargs.get("total_days", 11),)
diff --git a/posthog/queries/sessions.py b/posthog/queries/sessions.py
index 087d37ec4c8a3..cee7d4e9114a6 100644
--- a/posthog/queries/sessions.py
+++ b/posthog/queries/sessions.py
@@ -1,5 +1,4 @@
-import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 import pandas as pd
 from dateutil.relativedelta import relativedelta
@@ -10,6 +9,7 @@
 from django.utils.timezone import now
 
 from posthog.api.element import ElementSerializer
+from posthog.constants import SESSION_AVG, SESSION_DIST
 from posthog.models import ElementGroup, Event, Filter, Team
 from posthog.queries.base import BaseQuery, determine_compared_filter
 from posthog.utils import append_data, dict_from_cursor_fetchall, friendly_time
@@ -24,41 +24,36 @@ def run(self, filter: Filter, team: Team, *args, **kwargs) -> List[Dict[str, Any
             .order_by("-timestamp")
         )
 
-        session_type = kwargs.get("session_type", None)
-        offset = kwargs.get("offset", 0)
+        offset = filter.offset
 
         if not filter.date_to:
             filter._date_to = now().isoformat()
         calculated = []
 
         # get compared period
-        if filter.compare and filter._date_from != "all" and session_type == "avg":
-            calculated = self.calculate_sessions(
-                events.filter(filter.date_filter_Q), session_type, filter, team, offset
-            )
+        if filter.compare and filter._date_from != "all" and filter.session_type == SESSION_AVG:
+            calculated = self.calculate_sessions(events.filter(filter.date_filter_Q), filter, team, offset)
             calculated = self._convert_to_comparison(calculated, "current")
 
             compare_filter = determine_compared_filter(filter)
             compared_calculated = self.calculate_sessions(
-                events.filter(compare_filter.date_filter_Q), session_type, compare_filter, team, offset
+                events.filter(compare_filter.date_filter_Q), compare_filter, team, offset
             )
             converted_compared_calculated = self._convert_to_comparison(compared_calculated, "previous")
             calculated.extend(converted_compared_calculated)
         else:
             # if session_type is None, it's a list of sessions which shouldn't have any date filtering
-            if session_type is not None:
+            if filter.session_type is not None:
                 events = events.filter(filter.date_filter_Q)
-            calculated = self.calculate_sessions(events, session_type, filter, team, offset)
+            calculated = self.calculate_sessions(events, filter, team, offset)
 
         return calculated
 
-    def calculate_sessions(
-        self, events: QuerySet, session_type: Optional[str], filter: Filter, team: Team, offset: int
-    ) -> List[Dict[str, Any]]:
+    def calculate_sessions(self, events: QuerySet, filter: Filter, team: Team, offset: int) -> List[Dict[str, Any]]:
 
         # format date filter for session view
         _date_gte = Q()
-        if session_type is None:
+        if filter.session_type is None:
             # if _date_from is not explicitely set we only want to get the last day worth of data
             # otherwise the query is very slow
             if filter._date_from and filter.date_to:
@@ -106,9 +101,9 @@ def calculate_sessions(
         )
 
         result: List = []
-        if session_type == "avg":
+        if filter.session_type == SESSION_AVG:
             result = self._session_avg(all_sessions, sessions_sql_params, filter)
-        elif session_type == "dist":
+        elif filter.session_type == SESSION_DIST:
             result = self._session_dist(all_sessions, sessions_sql_params)
         else:
             result = self._session_list(all_sessions, sessions_sql_params, team, filter, offset)
diff --git a/posthog/api/test/test_paths.py b/posthog/queries/test/test_paths.py
similarity index 92%
rename from posthog/api/test/test_paths.py
rename to posthog/queries/test/test_paths.py
index c970011d14710..9cfcc3164b619 100644
--- a/posthog/api/test/test_paths.py
+++ b/posthog/queries/test/test_paths.py
@@ -2,9 +2,10 @@
 from django.utils.timezone import now
 from freezegun import freeze_time
 
-from posthog.models import Element, Event, Person
-
-from .base import BaseTest
+from posthog.api.test.base import BaseTest
+from posthog.models import Element, Event, Filter, Person
+from posthog.queries.paths import Paths
+from posthog.utils import request_to_date_query
 
 
 class TestPaths(BaseTest):
@@ -45,8 +46,8 @@ def test_current_url_paths_and_logic(self):
         Event.objects.create(
             properties={"$current_url": "/pricing"}, distinct_id="person_4", event="$pageview", team=self.team,
         )
-
-        response = self.client.get("/api/paths/").json()
+        filter = Filter(data={"date_from": "-7d"})
+        response = Paths().run(team=self.team, filter=filter)
         self.assertEqual(response[0]["source"], "1_/", response)
         self.assertEqual(response[0]["target"], "2_/pricing")
         self.assertEqual(response[0]["value"], 2)
@@ -81,16 +82,18 @@ def test_current_url_paths_and_logic(self):
 
         date_from = now() - relativedelta(days=7)
         date_to = now() + relativedelta(days=7)
-        response = self.client.get(
-            "/api/paths/?date_from=" + date_from.strftime("%Y-%m-%d") + "&date_to=" + date_to.strftime("%Y-%m-%d")
-        ).json()
+
+        date_params = {"date_from": date_from.strftime("%Y-%m-%d"), "date_to": date_to.strftime("%Y-%m-%d")}
+
+        filter = Filter(data={**date_params})
+        response = Paths().run(team=self.team, filter=filter)
         self.assertEqual(len(response), 4)
 
         date_from = now() + relativedelta(days=7)
         date_to = now() - relativedelta(days=7)
-        response = self.client.get(
-            "/api/paths/?date_from=" + date_from.strftime("%Y-%m-%d") + "&date_to=" + date_to.strftime("%Y-%m-%d")
-        ).json()
+        date_params = {"date_from": date_from.strftime("%Y-%m-%d"), "date_to": date_to.strftime("%Y-%m-%d")}
+        filter = Filter(data={**date_params})
+        response = Paths().run(team=self.team, filter=filter)
         self.assertEqual(len(response), 0)
 
     def test_custom_event_paths(self):
@@ -114,7 +117,8 @@ def test_custom_event_paths(self):
         Event.objects.create(distinct_id="person_4", event="custom_event_1", team=self.team)
         Event.objects.create(distinct_id="person_4", event="custom_event_2", team=self.team)
 
-        response = self.client.get("/api/paths/?type=custom_event").json()
+        response = Paths().run(team=self.team, filter=Filter(data={"path_type": "custom_event"}))
+
         self.assertEqual(response[0]["source"], "1_custom_event_1", response)
         self.assertEqual(response[0]["target"], "2_custom_event_2")
         self.assertEqual(response[0]["value"], 2)
@@ -167,7 +171,7 @@ def test_screen_paths(self):
             properties={"$screen_name": "/pricing"}, distinct_id="person_4", event="$screen", team=self.team,
         )
 
-        response = self.client.get("/api/paths/?type=%24screen").json()
+        response = Paths().run(team=self.team, filter=Filter(data={"path_type": "$screen"}))
         self.assertEqual(response[0]["source"], "1_/", response)
         self.assertEqual(response[0]["target"], "2_/pricing")
         self.assertEqual(response[0]["value"], 2)
@@ -234,7 +238,8 @@ def test_autocapture_paths(self):
                 Element(href="/a-url-2", nth_child=0, nth_of_type=0, order=2),
             ],
         )
-        response = self.client.get("/api/paths/?type=%24autocapture").json()
+        response = Paths().run(team=self.team, filter=Filter(data={"path_type": "$autocapture"}))
+
         self.assertEqual(response[0]["source"], "1_<a> hello")
         self.assertEqual(response[0]["target"], "2_<a> goodbye")
         self.assertEqual(response[0]["value"], 1)
@@ -299,9 +304,9 @@ def test_paths_properties_filter(self):
             properties={"$current_url": "/pricing"}, distinct_id="person_4", event="$pageview", team=self.team,
         )
 
-        response = self.client.get(
-            '/api/paths/?properties=%5B%7B"key"%3A"%24browser"%2C"value"%3A"Chrome"%2C"type"%3A"event"%7D%5D'
-        ).json()
+        filter = Filter(data={"properties": [{"key": "$browser", "value": "Chrome", "type": "event"}]})
+
+        response = Paths().run(team=self.team, filter=filter)
 
         self.assertEqual(response[0]["source"], "1_/")
         self.assertEqual(response[0]["target"], "2_/about")
@@ -352,6 +357,11 @@ def test_paths_start(self):
         )
 
         response = self.client.get("/api/paths/?type=%24pageview&start=%2Fpricing").json()
+
+        response = Paths().run(
+            team=self.team, filter=Filter(data={"path_type": "$pageview", "start_point": "/pricing"}),
+        )
+
         for item in response:
             self.assertEqual(item["source"], "1_/pricing")
 
@@ -376,7 +386,8 @@ def test_paths_in_window(self):
                 properties={"$current_url": "/about"}, distinct_id="person_1", event="$pageview", team=self.team,
             )
 
-        response = self.client.get("/api/paths/?date_from=2020-04-13").json()
+        response = Paths().run(team=self.team, filter=Filter(data={"date_from": "2020-04-13"}))
+
         self.assertEqual(response[0]["source"], "1_/")
         self.assertEqual(response[0]["target"], "2_/about")
         self.assertEqual(response[0]["value"], 2)
diff --git a/posthog/queries/test/test_retention.py b/posthog/queries/test/test_retention.py
index 083e738330d57..229ec742f899b 100644
--- a/posthog/queries/test/test_retention.py
+++ b/posthog/queries/test/test_retention.py
@@ -1,13 +1,12 @@
+import json
 from datetime import datetime
 
 import pytz
-from freezegun import freeze_time
 
 from posthog.api.test.base import BaseTest
 from posthog.constants import TREND_FILTER_TYPE_ACTIONS
-from posthog.models import Action, ActionStep, Entity, Event, Filter, Person, Team
+from posthog.models import Action, ActionStep, Event, Filter, Person
 from posthog.queries.retention import Retention
-from posthog.queries.stickiness import Stickiness
 
 
 class TestRetention(BaseTest):
@@ -119,9 +118,11 @@ def test_retention_action_start_point(self):
             ]
         )
 
-        start_entity = Entity({"id": action.pk, "type": TREND_FILTER_TYPE_ACTIONS})
+        start_entity = {"id": action.pk, "type": TREND_FILTER_TYPE_ACTIONS}
         result = Retention().run(
-            Filter(data={"date_from": self._date(0, hour=0), "entities": [start_entity]}), self.team, total_days=7
+            Filter(data={"date_from": self._date(0, hour=0), "target_entity": json.dumps(start_entity)}),
+            self.team,
+            total_days=7,
         )
 
         self.assertEqual(len(result), 7)
diff --git a/posthog/queries/test/test_sessions.py b/posthog/queries/test/test_sessions.py
index 296f29374e9db..a2a459be75564 100644
--- a/posthog/queries/test/test_sessions.py
+++ b/posthog/queries/test/test_sessions.py
@@ -22,15 +22,14 @@ def test_sessions_list(self):
             Event.objects.create(team=self.team, event="4th action", distinct_id="2", properties={"$os": "Windows 95"})
 
         with freeze_time("2012-01-15T04:01:34.000Z"):
-            response = Sessions().run(Filter(data={"events": []}), self.team, session_type=None)
+            response = Sessions().run(Filter(data={"events": [], "session": None}), self.team)
         self.assertEqual(len(response), 2)
         self.assertEqual(response[0]["global_session_id"], 1)
 
         with freeze_time("2012-01-15T04:01:34.000Z"):
             response = Sessions().run(
-                Filter(data={"events": [], "properties": [{"key": "$os", "value": "Mac OS X"}]}),
+                Filter(data={"events": [], "properties": [{"key": "$os", "value": "Mac OS X"}], "session": None}),
                 self.team,
-                session_type=None,
             )
         self.assertEqual(len(response), 1)
 
@@ -48,7 +47,7 @@ def test_sessions_avg_length(self):
             Event.objects.create(team=self.team, event="4th action", distinct_id="1")
             Event.objects.create(team=self.team, event="4th action", distinct_id="2")
 
-        response = Sessions().run(Filter(data={"date_from": "all"}), self.team, session_type="avg")
+        response = Sessions().run(Filter(data={"date_from": "all", "session": "avg"}), self.team)
         self.assertEqual(response[0]["count"], 3)  # average length of all sessions
 
         # time series
@@ -84,9 +83,8 @@ def test_sessions_avg_length_interval(self):
 
         # month
         month_response = Sessions().run(
-            Filter(data={"date_from": "2012-01-01", "date_to": "2012-04-01", "interval": "month"}),
+            Filter(data={"date_from": "2012-01-01", "date_to": "2012-04-01", "interval": "month", "session": "avg"}),
             self.team,
-            session_type="avg",
         )
         self.assertEqual(month_response[0]["data"][0], 180)
         self.assertEqual(month_response[0]["data"][2], 180)
@@ -97,9 +95,8 @@ def test_sessions_avg_length_interval(self):
 
         # # week
         week_response = Sessions().run(
-            Filter(data={"date_from": "2012-01-01", "date_to": "2012-02-01", "interval": "week"}),
+            Filter(data={"date_from": "2012-01-01", "date_to": "2012-02-01", "interval": "week", "session": "avg"}),
             self.team,
-            session_type="avg",
         )
         self.assertEqual(week_response[0]["data"][1], 240.0)
         self.assertEqual(week_response[0]["data"][3], 120.0)
@@ -110,9 +107,8 @@ def test_sessions_avg_length_interval(self):
 
         # # # hour
         hour_response = Sessions().run(
-            Filter(data={"date_from": "2012-03-14", "date_to": "2012-03-16", "interval": "hour"}),
+            Filter(data={"date_from": "2012-03-14", "date_to": "2012-03-16", "interval": "hour", "session": "avg"}),
             self.team,
-            session_type="avg",
         )
         self.assertEqual(hour_response[0]["data"][3], 240.0)
         self.assertEqual(hour_response[0]["data"][27], 120.0)
@@ -123,9 +119,8 @@ def test_sessions_avg_length_interval(self):
 
     def test_no_events(self):
         response = Sessions().run(
-            Filter(data={"date_from": "2012-01-20", "date_to": "2012-01-30", "interval": "day"}),
+            Filter(data={"date_from": "2012-01-20", "date_to": "2012-01-30", "interval": "day", "session": "avg"}),
             self.team,
-            session_type="avg",
         )
         self.assertEqual(response, [])
 
@@ -142,13 +137,17 @@ def test_compare(self):
         with freeze_time("2012-01-25T04:01:34.000Z"):
             Event.objects.create(team=self.team, event="4th action", distinct_id="1")
             Event.objects.create(team=self.team, event="4th action", distinct_id="2")
-
-        # Run without anything to compare to
-        compare_response = Sessions().run(
-            Filter(data={"date_from": "2012-01-20", "date_to": "2012-01-30", "interval": "day", "compare": True}),
-            self.team,
-            session_type="avg",
+        filter = Filter(
+            data={
+                "date_from": "2012-01-20",
+                "date_to": "2012-01-30",
+                "interval": "day",
+                "compare": True,
+                "session": "avg",
+            }
         )
+        # Run without anything to compare to
+        compare_response = Sessions().run(filter=filter, team=self.team)
         self.assertEqual(compare_response[0]["data"][5], 120.0)
         self.assertEqual(compare_response[1]["data"][4], 240.0)
 
@@ -209,9 +208,9 @@ def test_sessions_count_buckets(self):
         with freeze_time("2012-01-21T06:00:30.000Z"):
             Event.objects.create(team=self.team, event="3rd action", distinct_id="2")
 
-        response = Sessions().run(Filter(data={"date_from": "all"}), self.team, session_type="dist")
+        response = Sessions().run(Filter(data={"date_from": "all", "session": "dist"}), self.team)
         compared_response = Sessions().run(
-            Filter(data={"date_from": "all", "compare": True}), self.team, session_type="dist"
+            Filter(data={"date_from": "all", "compare": True, "session": "dist"}), self.team
         )
         for index, item in enumerate(response):
             if item["label"] == "30-60 minutes" or item["label"] == "3-10 seconds":
diff --git a/posthog/queries/trends.py b/posthog/queries/trends.py
index 96d5997b96300..fae7e8587d6c0 100644
--- a/posthog/queries/trends.py
+++ b/posthog/queries/trends.py
@@ -1,8 +1,6 @@
 import copy
 import datetime
-import json
-from datetime import timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -25,27 +23,20 @@
 from django.db.models.expressions import RawSQL, Subquery
 from django.db.models.functions import Cast
 from django.utils.timezone import now
-from rest_framework import authentication, request, serializers, viewsets
-from rest_framework.decorators import action
-from rest_framework.response import Response
 
-from posthog.constants import TREND_FILTER_TYPE_ACTIONS, TREND_FILTER_TYPE_EVENTS, TRENDS_CUMULATIVE, TRENDS_STICKINESS
-from posthog.decorators import TRENDS_ENDPOINT, cached_function
+from posthog.constants import TREND_FILTER_TYPE_ACTIONS, TRENDS_CUMULATIVE
 from posthog.models import (
     Action,
     ActionStep,
     Cohort,
     CohortPeople,
-    DashboardItem,
     Entity,
     Event,
     Filter,
     Person,
     Team,
-    User,
 )
-from posthog.tasks.calculate_action import calculate_action
-from posthog.utils import TemporaryTokenAuthentication, append_data
+from posthog.utils import append_data
 
 from .base import BaseQuery, filter_events, handle_compare, process_entity_for_events