diff --git a/bitmovin-analytics-datasource/src/components/QueryEditor.tsx b/bitmovin-analytics-datasource/src/components/QueryEditor.tsx
index f9b0647..3f4c22f 100644
--- a/bitmovin-analytics-datasource/src/components/QueryEditor.tsx
+++ b/bitmovin-analytics-datasource/src/components/QueryEditor.tsx
@@ -1,32 +1,99 @@
-import React, { ChangeEvent } from 'react';
-import { InlineField, Input } from '@grafana/ui';
-import { QueryEditorProps } from '@grafana/data';
+import React, { ChangeEvent, useEffect, useState } from 'react';
+import { FieldSet, InlineField, InlineSwitch, Select } from '@grafana/ui';
+import { QueryEditorProps, SelectableValue } from '@grafana/data';
+
 import { DataSource } from '../datasource';
-import { MyDataSourceOptions, MyQuery } from '../types';
+import { MyDataSourceOptions, BitmovinAnalyticsDataQuery } from '../types';
+import { fetchLicenses } from '../utils/licenses';
+import { DEFAULT_SELECTABLE_QUERY_INTERVAL, SELECTABLE_QUERY_INTERVALS } from '../utils/intervalUtils';
+
+enum LoadingState {
+  Default = 'DEFAULT',
+  Loading = 'LOADING',
+  Success = 'SUCCESS',
+  Error = 'ERROR',
+}
+
+type Props = QueryEditorProps<DataSource, BitmovinAnalyticsDataQuery, MyDataSourceOptions>;
+
+export function QueryEditor({ query, onChange, onRunQuery, datasource }: Props) {
+  const [selectableLicenses, setSelectableLicenses] = useState<SelectableValue[]>([]);
+  const [licenseLoadingState, setLicenseLoadingState] = useState<LoadingState>(LoadingState.Default);
+  const [licenseErrorMessage, setLicenseErrorMessage] = useState('');
+  const [isTimeSeries, setIsTimeSeries] = useState(true);
 
-type Props = QueryEditorProps<DataSource, MyQuery, MyDataSourceOptions>;
+  useEffect(() => {
+    setLicenseLoadingState(LoadingState.Loading);
+    fetchLicenses(datasource.apiKey, datasource.baseUrl)
+      .then((licenses) => {
+        setSelectableLicenses(licenses);
+        setLicenseLoadingState(LoadingState.Success);
+      })
+      .catch((e) => {
+        setLicenseLoadingState(LoadingState.Error);
+        setLicenseErrorMessage(e.status + ' ' + e.statusText);
+      });
+  }, [datasource.apiKey, datasource.baseUrl]);
 
-export function QueryEditor({ query, onChange, onRunQuery }: Props) {
-  const onQueryTextChange = (event: ChangeEvent<HTMLInputElement>) => {
-    onChange({ ...query, queryText: event.target.value });
+  const onLicenseChange = (item: SelectableValue) => {
+    onChange({ ...query, licenseKey: item.value });
+    onRunQuery();
   };
 
-  const onConstantChange = (event: ChangeEvent<HTMLInputElement>) => {
-    onChange({ ...query, constant: parseFloat(event.target.value) });
-    // executes the query
+  const onFormatAsTimeSeriesChange = (event: ChangeEvent<HTMLInputElement>) => {
+    setIsTimeSeries(event.currentTarget.checked);
+    if (event.currentTarget.checked) {
+      onChange({ ...query, interval: 'AUTO' });
+    } else {
+      onChange({ ...query, interval: undefined });
+    }
     onRunQuery();
   };
 
-  const { queryText, constant } = query;
+  const onIntervalChange = (item: SelectableValue) => {
+    onChange({ ...query, interval: item.value });
+    onRunQuery();
+  };
+
+  const renderTimeSeriesOption = () => {
+    return (
+      <>
+        <InlineField label="Interval" labelWidth={20}>
+          <Select
+            defaultValue={DEFAULT_SELECTABLE_QUERY_INTERVAL}
+            onChange={(item) => onIntervalChange(item)}
+            width={40}
+            options={SELECTABLE_QUERY_INTERVALS}
+          />
+        </InlineField>
+      </>
+    );
+  };
 
   return (
     <div className="gf-form">
-      <InlineField label="Constant">
-        <Input onChange={onConstantChange} value={constant} width={8} type="number" step="0.1" />
-      </InlineField>
-      <InlineField label="Query Text" labelWidth={16} tooltip="Not used yet">
-        <Input onChange={onQueryTextChange} value={queryText || ''} />
-      </InlineField>
+      <FieldSet>
+        <InlineField
+          label="License"
+          labelWidth={20}
+          invalid={licenseLoadingState === LoadingState.Error}
+          error={`Error when fetching Analytics Licenses: ${licenseErrorMessage}`}
+          disabled={licenseLoadingState === LoadingState.Error}
+        >
+          <Select
+            onChange={onLicenseChange}
+            width={40}
+            options={selectableLicenses}
+            noOptionsMessage="No Analytics Licenses found"
+            isLoading={licenseLoadingState === LoadingState.Loading}
+            placeholder={licenseLoadingState === LoadingState.Loading ? 'Loading Licenses' : 'Choose License'}
+          />
+        </InlineField>
+        <InlineField label="Format as time series" labelWidth={20}>
+          <InlineSwitch value={isTimeSeries} onChange={onFormatAsTimeSeriesChange}></InlineSwitch>
+        </InlineField>
+        {isTimeSeries && renderTimeSeriesOption()}
+      </FieldSet>
     </div>
   );
 }
diff --git a/bitmovin-analytics-datasource/src/datasource.ts b/bitmovin-analytics-datasource/src/datasource.ts
index fc7eb92..da62b9e 100644
--- a/bitmovin-analytics-datasource/src/datasource.ts
+++ b/bitmovin-analytics-datasource/src/datasource.ts
@@ -9,9 +9,9 @@ import {
 import { getBackendSrv } from '@grafana/runtime';
 import { catchError, lastValueFrom, map, Observable, of } from 'rxjs';
 
-import { MixedDataRowList, MyDataSourceOptions, MyQuery, NumberDataRowList } from './types';
+import { MixedDataRowList, MyDataSourceOptions, BitmovinAnalyticsDataQuery, NumberDataRowList } from './types';
 import { transformGroupedTimeSeriesData, transformSimpleTimeSeries, transformTableData } from './utils/dataUtils';
-import { QueryInterval } from './utils/intervalUtils';
+import { calculateQueryInterval, QueryInterval } from './utils/intervalUtils';
 
 type AnalyticsQuery = {
   filters: Array<{ name: string; operator: string; value: number }>;
@@ -24,7 +24,7 @@ type AnalyticsQuery = {
   interval?: QueryInterval;
 };
 
-export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
+export class DataSource extends DataSourceApi<BitmovinAnalyticsDataQuery, MyDataSourceOptions> {
   baseUrl: string;
   apiKey: string;
   tenantOrgId?: string;
@@ -48,34 +48,40 @@ export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
    *      - Interval is not set: All values up to the last one (not included) can be considered string values
    * - The last value of each row is always be a number.
    * */
-  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
+  async query(options: DataQueryRequest<BitmovinAnalyticsDataQuery>): Promise<DataQueryResponse> {
     const { range } = options;
-    const from = new Date(range!.from.toDate().setSeconds(0, 0));
+    const from = range!.from.toDate();
     const to = range!.to.toDate();
 
-    const query: AnalyticsQuery = {
-      filters: [
-        {
-          name: 'VIDEO_STARTUPTIME',
-          operator: 'GT',
-          value: 0,
-        },
-      ],
-      groupBy: [],
-      orderBy: [
-        {
-          name: 'MINUTE',
-          order: 'DESC',
-        },
-      ],
-      dimension: 'IMPRESSION_ID',
-      start: from,
-      end: to,
-      licenseKey: '',
-      interval: 'MINUTE',
-    };
-
     const promises = options.targets.map(async (target) => {
+      const interval = target.interval
+        ? calculateQueryInterval(target.interval!, from.getTime(), to.getTime())
+        : undefined;
+
+      const query: AnalyticsQuery = {
+        filters: [
+          {
+            name: 'VIDEO_STARTUPTIME',
+            operator: 'GT',
+            value: 0,
+          },
+        ],
+        groupBy: [],
+        orderBy: interval
+          ? [
+              {
+                name: interval,
+                order: 'DESC',
+              },
+            ]
+          : [],
+        dimension: 'IMPRESSION_ID',
+        start: from,
+        end: to,
+        licenseKey: target.licenseKey,
+        interval: interval,
+      };
+
       const response = await lastValueFrom(this.request(this.getRequestUrl(), 'POST', query));
 
       const dataRows: MixedDataRowList = response.data.data.result.rows;
diff --git a/bitmovin-analytics-datasource/src/module.ts b/bitmovin-analytics-datasource/src/module.ts
index b8231eb..6f16065 100644
--- a/bitmovin-analytics-datasource/src/module.ts
+++ b/bitmovin-analytics-datasource/src/module.ts
@@ -2,8 +2,8 @@ import { DataSourcePlugin } from '@grafana/data';
 import { DataSource } from './datasource';
 import { ConfigEditor } from './components/ConfigEditor';
 import { QueryEditor } from './components/QueryEditor';
-import { MyQuery, MyDataSourceOptions } from './types';
+import { BitmovinAnalyticsDataQuery, MyDataSourceOptions } from './types';
 
-export const plugin = new DataSourcePlugin<DataSource, MyQuery, MyDataSourceOptions>(DataSource)
+export const plugin = new DataSourcePlugin<DataSource, BitmovinAnalyticsDataQuery, MyDataSourceOptions>(DataSource)
   .setConfigEditor(ConfigEditor)
   .setQueryEditor(QueryEditor);
diff --git a/bitmovin-analytics-datasource/src/types.ts b/bitmovin-analytics-datasource/src/types.ts
index bed9c31..e2ec81e 100644
--- a/bitmovin-analytics-datasource/src/types.ts
+++ b/bitmovin-analytics-datasource/src/types.ts
@@ -1,14 +1,13 @@
 import { DataSourceJsonData } from '@grafana/data';
 import { DataQuery } from '@grafana/schema';
+import { QueryInterval } from './utils/intervalUtils';
 
-export interface MyQuery extends DataQuery {
-  queryText?: string;
-  constant: number;
+export interface BitmovinAnalyticsDataQuery extends DataQuery {
+  licenseKey: string;
+  interval?: QueryInterval | 'AUTO';
 }
 
-export const DEFAULT_QUERY: Partial<MyQuery> = {
-  constant: 6.5,
-};
+export const DEFAULT_QUERY: Partial<BitmovinAnalyticsDataQuery> = {};
 
 /**
  * These are options configured for each DataSource instance
diff --git a/bitmovin-analytics-datasource/src/utils/dataUtils.test.ts b/bitmovin-analytics-datasource/src/utils/dataUtils.test.ts
index ab37f0f..57820ee 100644
--- a/bitmovin-analytics-datasource/src/utils/dataUtils.test.ts
+++ b/bitmovin-analytics-datasource/src/utils/dataUtils.test.ts
@@ -7,14 +7,15 @@ import {
 import { FieldType } from '@grafana/data';
 
 describe('padAndSortTimeSeries', () => {
-  it('should return sorted and padded data for simple time series data', () => {
+  it('should return sorted and padded data for simple time series data for MINUTE interval', () => {
     //arrange
     const data = [
+      [1712919540000, 1], //Friday, 12 April 2024 10:59:00
       [1712919600000, 2], //Friday, 12 April 2024 11:00:00
       [1712919720000, 5], //Friday, 12 April 2024 11:02:00
     ];
 
-    const startTimestamp = 1712919540000; //Friday, 12 April 2024 10:59:00
+    const startTimestamp = 1712919560000; //Friday, 12 April 2024 10:59:20
     const endTimestamp = 1712919780000; //Friday, 12 April 2024 11:03:00
 
     //act
@@ -22,7 +23,6 @@ describe('padAndSortTimeSeries', () => {
 
     //assert
     expect(result).toEqual([
-      [1712919540000, 0],
       [1712919600000, 2],
       [1712919660000, 0],
       [1712919720000, 5],
@@ -30,14 +30,64 @@ describe('padAndSortTimeSeries', () => {
     ]);
   });
 
-  it('should return sorted and padded data for grouped time series data', () => {
+  it('should return sorted and padded data for simple time series data for HOUR Interval', () => {
+    //arrange
+    const data = [
+      [1712916000000, 1], //Friday, 12 April 2024 10:00:00
+      [1712919600000, 7], //Friday, 12 April 2024 11:00:00
+      [1712930400000, 5], //Friday, 12 April 2024 14:00:00
+      [1712934000000, 2], //Friday, 12 April 2024 15:00:00
+    ];
+
+    const startTimestamp = 1712917444000; //Friday, 12 April 2024 10:24:04
+    const endTimestamp = 1712935444000; //Friday, 12 April 2024 15:24:04
+
+    //act
+    const result = padAndSortTimeSeries(data, startTimestamp, endTimestamp, 'HOUR');
+
+    //assert
+    expect(result).toEqual([
+      [1712919600000, 7], //Friday, 12 April 2024 11:00:00
+      [1712923200000, 0], //Friday, 12 April 2024 12:00:00
+      [1712926800000, 0], //Friday, 12 April 2024 13:00:00
+      [1712930400000, 5], //Friday, 12 April 2024 14:00:00
+      [1712934000000, 2], //Friday, 12 April 2024 15:00:00
+    ]);
+  });
+
+  it('should return sorted and padded data for simple time series data for DAY interval', () => {
+    //arrange
+    const data = [
+      [1712917800000, 1], //Friday, 12 April 2024 10:30:00
+      [1713004200000, 2], //Saturday, 13 April 2024 10:30:00
+      [1713263400000, 5], //Tuesday, 16 April 2024 10:30:00
+    ];
+
+    const startTimestamp = 1712919560000; //Friday, 12 April 2024 10:59:20
+    const endTimestamp = 1713351560000; //Wednesday, 17 April 2024 10:59:20
+
+    //act
+    const result = padAndSortTimeSeries(data, startTimestamp, endTimestamp, 'DAY');
+
+    //assert
+    expect(result).toEqual([
+      [1713004200000, 2], //Saturday, 13 April 2024 10:30:00
+      [1713090600000, 0], //Sunday, 14 April 2024 10:30:00
+      [1713177000000, 0], //Monday, 15 April 2024 10:30:00
+      [1713263400000, 5], //Tuesday, 16 April 2024 10:30:00
+      [1713349800000, 0], //Wednesday, 17 April 2024 10:30:00
+    ]);
+  });
+
+  it('should return sorted and padded data for grouped time series data for MINUTE interval', () => {
     //arrange
     const data = [
+      [1712919540000, 'BROWSER', 'DEVICE_TYPE', 1], //Friday, 12 April 2024 10:59:00
       [1712919600000, 'BROWSER', 'DEVICE_TYPE', 2], //Friday, 12 April 2024 11:00:00
       [1712919720000, 'BROWSER', 'DEVICE_TYPE', 5], //Friday, 12 April 2024 11:02:00
     ];
 
-    const startTimestamp = 1712919540000; //Friday, 12 April 2024 10:59:00
+    const startTimestamp = 1712919560000; //Friday, 12 April 2024 10:59:20
     const endTimestamp = 1712919780000; //Friday, 12 April 2024 11:03:00
 
     //act
@@ -45,7 +95,6 @@ describe('padAndSortTimeSeries', () => {
 
     //assert
     expect(result).toEqual([
-      [1712919540000, 'BROWSER', 'DEVICE_TYPE', 0],
       [1712919600000, 'BROWSER', 'DEVICE_TYPE', 2],
       [1712919660000, 'BROWSER', 'DEVICE_TYPE', 0],
       [1712919720000, 'BROWSER', 'DEVICE_TYPE', 5],
@@ -53,6 +102,55 @@ describe('padAndSortTimeSeries', () => {
     ]);
   });
 
+  it('should return sorted and padded data for grouped time series data for HOUR interval', () => {
+    //arrange
+    const data = [
+      [1712916000000, 'BROWSER', 'DEVICE_TYPE', 1], //Friday, 12 April 2024 10:00:00
+      [1712919600000, 'BROWSER', 'DEVICE_TYPE', 7], //Friday, 12 April 2024 11:00:00
+      [1712930400000, 'BROWSER', 'DEVICE_TYPE', 5], //Friday, 12 April 2024 14:00:00
+      [1712934000000, 'BROWSER', 'DEVICE_TYPE', 2], //Friday, 12 April 2024 15:00:00
+    ];
+
+    const startTimestamp = 1712917444000; //Friday, 12 April 2024 10:24:04
+    const endTimestamp = 1712935444000; //Friday, 12 April 2024 15:24:04
+
+    //act
+    const result = padAndSortTimeSeries(data, startTimestamp, endTimestamp, 'HOUR');
+
+    //assert
+    expect(result).toEqual([
+      [1712919600000, 'BROWSER', 'DEVICE_TYPE', 7], //Friday, 12 April 2024 11:00:00
+      [1712923200000, 'BROWSER', 'DEVICE_TYPE', 0], //Friday, 12 April 2024 12:00:00
+      [1712926800000, 'BROWSER', 'DEVICE_TYPE', 0], //Friday, 12 April 2024 13:00:00
+      [1712930400000, 'BROWSER', 'DEVICE_TYPE', 5], //Friday, 12 April 2024 14:00:00
+      [1712934000000, 'BROWSER', 'DEVICE_TYPE', 2], //Friday, 12 April 2024 15:00:00
+    ]);
+  });
+
+  it('should return sorted and padded data for grouped time series data for DAY interval', () => {
+    //arrange
+    const data = [
+      [1712917800000, 'BROWSER', 'DEVICE_TYPE', 1], //Friday, 12 April 2024 10:30:00
+      [1713004200000, 'BROWSER', 'DEVICE_TYPE', 2], //Saturday, 13 April 2024 10:30:00
+      [1713263400000, 'BROWSER', 'DEVICE_TYPE', 5], //Tuesday, 16 April 2024 10:30:00
+    ];
+
+    const startTimestamp = 1712919560000; //Friday, 12 April 2024 10:59:20
+    const endTimestamp = 1713351560000; //Wednesday, 17 April 2024 10:59:20
+
+    //act
+    const result = padAndSortTimeSeries(data, startTimestamp, endTimestamp, 'DAY');
+
+    //assert
+    expect(result).toEqual([
+      [1713004200000, 'BROWSER', 'DEVICE_TYPE', 2], //Saturday, 13 April 2024 10:30:00
+      [1713090600000, 'BROWSER', 'DEVICE_TYPE', 0], //Sunday, 14 April 2024 10:30:00
+      [1713177000000, 'BROWSER', 'DEVICE_TYPE', 0], //Monday, 15 April 2024 10:30:00
+      [1713263400000, 'BROWSER', 'DEVICE_TYPE', 5], //Tuesday, 16 April 2024 10:30:00
+      [1713349800000, 'BROWSER', 'DEVICE_TYPE', 0], //Wednesday, 17 April 2024 10:30:00
+    ]);
+  });
+
   it('should throw error when interval is not valid', () => {
     //arrange
     const data = [[0, 0]];
diff --git a/bitmovin-analytics-datasource/src/utils/dataUtils.ts b/bitmovin-analytics-datasource/src/utils/dataUtils.ts
index 1467836..0ce63b7 100644
--- a/bitmovin-analytics-datasource/src/utils/dataUtils.ts
+++ b/bitmovin-analytics-datasource/src/utils/dataUtils.ts
@@ -1,5 +1,5 @@
 import { differenceWith, sortBy, zip } from 'lodash';
-import { intervalToMilliseconds, QueryInterval } from './intervalUtils';
+import { ceilTimestampAccordingToQueryInterval, intervalToMilliseconds, QueryInterval } from './intervalUtils';
 import { Field, FieldType } from '@grafana/data';
 import { MixedDataRow, MixedDataRowList, NumberDataRow, NumberDataRowList } from '../types';
 
@@ -27,6 +27,9 @@ export function padAndSortTimeSeries(
     throw new Error(`Query interval ${interval} is not a valid interval.`);
   }
 
+  // ceil timestamp to pad data with accurate timestamps and to ignore incomplete first datapoints
+  const ceiledTimestamp = ceilTimestampAccordingToQueryInterval(startTimestamp, interval, data[0][0] as number);
+
   let dataRows: MixedDataRow = [0];
   const zeroValueTimeSeries: MixedDataRowList = [];
 
@@ -36,7 +39,7 @@ export function padAndSortTimeSeries(
   }
 
   // Create zero value time series data for the entire interval
-  for (let timestamp = startTimestamp; timestamp <= endTimestamp; timestamp += intervalInMs) {
+  for (let timestamp = ceiledTimestamp; timestamp <= endTimestamp; timestamp += intervalInMs) {
     const row = [timestamp, ...dataRows];
     zeroValueTimeSeries.push(row);
   }
@@ -50,7 +53,14 @@ export function padAndSortTimeSeries(
   // Sort data by timestamp
   const sortedData = sortBy(paddedData, (row) => row[0]);
 
-  return sortedData;
+  // Ignore datapoints before ceiled start timestamp to only show complete datapoints and to not overflow graph to the left
+  let index = 0;
+  while (sortedData[index][0] < ceiledTimestamp) {
+    index++;
+  }
+  const trimmedData = sortedData.slice(index);
+
+  return trimmedData;
 }
 
 /**
diff --git a/bitmovin-analytics-datasource/src/utils/intervalUtils.test.ts b/bitmovin-analytics-datasource/src/utils/intervalUtils.test.ts
new file mode 100644
index 0000000..a0ce99c
--- /dev/null
+++ b/bitmovin-analytics-datasource/src/utils/intervalUtils.test.ts
@@ -0,0 +1,175 @@
+import { calculateQueryInterval, ceilTimestampAccordingToQueryInterval } from './intervalUtils';
+
+describe('calculateQueryInterval', () => {
+  it('should return correct given interval if interval is not AUTO', () => {
+    //arrange
+    const startTimestamp = 1713349080000; //Wednesday, 17 April 2024 10:18:00
+    const endTimestamp = 1713356280000; //Wednesday, 17 April 2024 12:18:00
+    const interval = 'MINUTE';
+
+    // act
+    const result = calculateQueryInterval(interval, startTimestamp, endTimestamp);
+
+    //assert
+    expect(result).toEqual(interval);
+  });
+
+  it('should return MINUTE interval if interval is AUTO and time interval below 3 hours', () => {
+    //arrange
+    const startTimestamp = 1713349080000; //Wednesday, 17 April 2024 10:18:00
+    const endTimestamp = 1713356280000; //Wednesday, 17 April 2024 12:18:00
+
+    // act
+    const result = calculateQueryInterval('AUTO', startTimestamp, endTimestamp);
+
+    //assert
+    expect(result).toEqual('MINUTE');
+  });
+
+  it('should return HOUR interval if interval is AUTO and time interval bigger 3 hours and than below 6 hours', () => {
+    //arrange
+    const startTimestamp = 1713345420000; //Wednesday, 17 April 2024 09:17:00
+    const endTimestamp = 1713356280000; //Wednesday, 17 April 2024 12:18:00
+
+    // act
+    const result = calculateQueryInterval('AUTO', startTimestamp, endTimestamp);
+
+    //assert
+    expect(result).toEqual('HOUR');
+  });
+
+  it('should return DAY interval if interval is AUTO and time interval bigger than 6 days', () => {
+    //arrange
+    const startTimestamp = 1712837820000; //Thursday, 11 April 2024 12:17:00
+    const endTimestamp = 1713356280000; //Wednesday, 17 April 2024 12:18:00
+
+    // act
+    const result = calculateQueryInterval('AUTO', startTimestamp, endTimestamp);
+
+    //assert
+    expect(result).toEqual('DAY');
+  });
+});
+
+describe('ceilTimestampAccordingToQueryInterval', () => {
+  it('should return same timestamp for already rounded MINUTE interval start timestamp ', () => {
+    //arrange
+    const startTimestamp = 1713513900000; //Friday, 19 April 2024 08:05:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'MINUTE', 0);
+
+    //assert
+    expect(result).toEqual(startTimestamp);
+  });
+
+  it('should return ceiled timestamp for MINUTE interval and start timestamp with milliseconds != 0', () => {
+    //arrange
+    const startTimestamp = 1713513900100; //Friday, 19 April 2024 08:05:00.100
+    const expectedTimestamp = 1713513960000; //Friday, 19 April 2024 08:06:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'MINUTE', 0);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return ceiled timestamp for MINUTE interval and start timestamp with seconds != 0', () => {
+    //arrange
+    const startTimestamp = 1713513912000; //Friday, 19 April 2024 08:05:12
+    const expectedTimestamp = 1713513960000; //Friday, 19 April 2024 08:06:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'MINUTE', 0);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return same timestamp for already rounded HOUR interval start timestamp ', () => {
+    //arrange
+    const startTimestamp = 1713513600000; //Friday, 19 April 2024 08:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'HOUR', 0);
+
+    //assert
+    expect(result).toEqual(startTimestamp);
+  });
+
+  it('should return ceiled timestamp for HOUR interval and start timestamp with milliseconds != 0', () => {
+    //arrange
+    const startTimestamp = 1713513600100; //Friday, 19 April 2024 08:00:00.100
+    const expectedTimestamp = 1713517200000; //Friday, 19 April 2024 09:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'HOUR', 0);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return ceiled timestamp for HOUR interval and start timestamp with seconds != 0', () => {
+    //arrange
+    const startTimestamp = 1713513612000; //Friday, 19 April 2024 08:00:12
+    const expectedTimestamp = 1713517200000; //Friday, 19 April 2024 09:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'HOUR', 0);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return ceiled timestamp for HOUR interval and start timestamp with minutes != 0', () => {
+    //arrange
+    const startTimestamp = 1713514320000; //Friday, 19 April 2024 08:12:00
+    const expectedTimestamp = 1713517200000; //Friday, 19 April 2024 09:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'HOUR', 0);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return correct timestamp with DAY interval and start timestamp before data timestamp', () => {
+    //arrange
+    const startTimestamp = 1713514320000; //Friday, 19 April 2024 08:12:00
+    const dataTimestamp = 1713954600000; //Wednesday, 24 April 2024 10:30:00
+    const expectedTimestamp = 1713522600000; //Friday, 19 April 2024 10:30:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'DAY', dataTimestamp);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return ceiled timestamp with DAY interval and start timestamp after data timestamp', () => {
+    //arrange
+    const startTimestamp = 1713522184000; //Friday, 19 April 2024 10:23:04
+    const dataTimestamp = 1713517200000; //Friday, 19 April 2024 09:00:00
+    const expectedTimestamp = 1713603600000; //Saturday, 20 April 2024 09:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(startTimestamp, 'DAY', dataTimestamp);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+
+  it('should return ceiled timestamp with DAY interval and start timestamp after data timestamp and start timestamp being last day of a month', () => {
+    //arrange
+    const timestamp = 1714474760000; //Tuesday, 30 April 2024 10:59:20
+    const dataTimestamp = 1714467600000; //Tuesday, 30 April 2024 09:00:00
+    const expectedTimestamp = 1714554000000; //Wednesday, 1 May 2024 09:00:00
+
+    //act
+    const result = ceilTimestampAccordingToQueryInterval(timestamp, 'DAY', dataTimestamp);
+
+    //assert
+    expect(result).toEqual(expectedTimestamp);
+  });
+});
diff --git a/bitmovin-analytics-datasource/src/utils/intervalUtils.ts b/bitmovin-analytics-datasource/src/utils/intervalUtils.ts
index 1cf9787..b473d20 100644
--- a/bitmovin-analytics-datasource/src/utils/intervalUtils.ts
+++ b/bitmovin-analytics-datasource/src/utils/intervalUtils.ts
@@ -1,5 +1,16 @@
 export type QueryInterval = 'MINUTE' | 'HOUR' | 'DAY';
 
+export type SelectableQueryInterval = QueryInterval | 'AUTO';
+
+export const SELECTABLE_QUERY_INTERVALS: Array<{ value: SelectableQueryInterval | 'AUTO'; label: string }> = [
+  { value: 'AUTO', label: 'Auto' },
+  { value: 'MINUTE', label: 'Minute' },
+  { value: 'HOUR', label: 'Hour' },
+  { value: 'DAY', label: 'Day' },
+];
+
+export const DEFAULT_SELECTABLE_QUERY_INTERVAL = SELECTABLE_QUERY_INTERVALS[0];
+
 /**
  * Get corresponding interval in milliseconds.
  *
@@ -18,3 +29,76 @@ export const intervalToMilliseconds = (interval: QueryInterval): number => {
       return -1;
   }
 };
+
+/**
+ * Calculates the Query interval based on a given selected interval, start timestamp and end timestamp
+ *
+ * @param {SelectableQueryInterval} interval The selected interval
+ * @param {number} startTimestamp The start timestamp in milliseconds
+ * @param {number} endTimestamp The end timestamp in milliseconds
+ * @returns {QueryInterval} calculated Interval as QueryInterval
+ */
+export const calculateQueryInterval = (
+  interval: SelectableQueryInterval,
+  startTimestamp: number,
+  endTimestamp: number
+): QueryInterval => {
+  if (interval !== 'AUTO') {
+    return interval as QueryInterval;
+  }
+
+  const intervalInMilliseconds = endTimestamp - startTimestamp;
+  const minuteIntervalLimitInMilliseconds = 3 * 60 * 60 * 1000; // MINUTE granularity for timeframes below 3h
+  const hourIntervalLimitInMilliseconds = 6 * 24 * 60 * 60 * 1000; // HOUR granularity for timeframes below 6d
+
+  if (intervalInMilliseconds <= minuteIntervalLimitInMilliseconds) {
+    return 'MINUTE';
+  } else if (intervalInMilliseconds <= hourIntervalLimitInMilliseconds) {
+    return 'HOUR';
+  }
+  return 'DAY';
+};
+
+/**
+ * Rounds up a timestamp according to the specified query interval.
+ *
+ * @param {number} startTimestamp The start timestamp of the query.
+ * @param {QueryInterval} interval       The query interval.
+ * @param {number} dataTimestamp  The timestamp of a data point. Needed to calculate correct Day interval timestamp.
+ * @return {number} The rounded up timestamp.
+ */
+export function ceilTimestampAccordingToQueryInterval(
+  startTimestamp: number,
+  interval: QueryInterval,
+  dataTimestamp: number
+): number {
+  const startDate = new Date(startTimestamp);
+  switch (interval) {
+    case 'MINUTE':
+      if (startDate.getSeconds() === 0 && startDate.getMilliseconds() === 0) {
+        return startTimestamp;
+      }
+      return startDate.setMinutes(startDate.getMinutes() + 1, 0, 0);
+    case 'HOUR':
+      if (startDate.getMinutes() === 0 && startDate.getSeconds() === 0 && startDate.getMilliseconds() === 0) {
+        return startTimestamp;
+      }
+      return startDate.setHours(startDate.getHours() + 1, 0, 0, 0);
+    case 'DAY':
+      // Take the hours and minutes value from the datapoint timestamps as the timestamps for the day interval depend on the timezone of the license
+      const dataHours = new Date(dataTimestamp).getHours();
+      const dataMinutes = new Date(dataTimestamp).getMinutes();
+      const startDateWithCorrectTime = new Date(
+        startDate.getFullYear(),
+        startDate.getMonth(),
+        startDate.getDate(),
+        dataHours,
+        dataMinutes
+      );
+
+      if (startDateWithCorrectTime.getTime() > startTimestamp) {
+        return startDateWithCorrectTime.getTime();
+      }
+      return new Date(startDateWithCorrectTime).setDate(startDateWithCorrectTime.getDate() + 1);
+  }
+}
diff --git a/bitmovin-analytics-datasource/src/utils/licenses.ts b/bitmovin-analytics-datasource/src/utils/licenses.ts
new file mode 100644
index 0000000..c4b4107
--- /dev/null
+++ b/bitmovin-analytics-datasource/src/utils/licenses.ts
@@ -0,0 +1,71 @@
+import { lastValueFrom } from 'rxjs';
+import { getBackendSrv } from '@grafana/runtime';
+import { SelectableValue } from '@grafana/data';
+
+type AnalyticsLicense = {
+  readonly name: string;
+  readonly id: string;
+  readonly licenseKey?: string;
+};
+
+const licenseEndpoints = [
+  {
+    endpoint: '/analytics/licenses',
+    mapperFunc: (license: AnalyticsLicense): SelectableValue => ({
+      value: license.licenseKey,
+      label: license.name ? license.name : license.licenseKey,
+    }),
+  },
+  {
+    endpoint: '/analytics/virtual-licenses',
+    mapperFunc: (license: AnalyticsLicense): SelectableValue => ({
+      value: license.id,
+      label: license.name ? license.name : license.id,
+    }),
+  },
+  {
+    endpoint: '/analytics/demo-licenses',
+    mapperFunc: (license: AnalyticsLicense): SelectableValue => ({
+      value: license.id,
+      label: license.name ? license.name : license.id,
+    }),
+  },
+];
+
+async function fetchLicensesForEndpoint(
+  url: string,
+  apiKey: string,
+  mapperFunc: (license: AnalyticsLicense) => SelectableValue
+) {
+  const options = {
+    url: url,
+    headers: { 'X-Api-Key': apiKey },
+    method: 'GET',
+  };
+
+  const response = await lastValueFrom(getBackendSrv().fetch(options));
+  // @ts-ignore
+  const licenses = response.data.data.result.items;
+
+  const selectableLicenses = [];
+  for (const license of licenses) {
+    selectableLicenses.push(mapperFunc(license));
+  }
+
+  return selectableLicenses;
+}
+
+export async function fetchLicenses(apiKey: string, baseUrl: string): Promise<SelectableValue[]> {
+  const allLicenses: SelectableValue[] = [];
+
+  for (const licenseEndpoint of licenseEndpoints) {
+    const licenses = await fetchLicensesForEndpoint(
+      baseUrl + licenseEndpoint.endpoint,
+      apiKey,
+      licenseEndpoint.mapperFunc
+    );
+    allLicenses.push(...licenses);
+  }
+
+  return allLicenses;
+}