diff --git a/nowcasting_dataset/consts.py b/nowcasting_dataset/consts.py
index 86821320..9bed4fd2 100644
--- a/nowcasting_dataset/consts.py
+++ b/nowcasting_dataset/consts.py
@@ -133,6 +133,5 @@
 SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME = (
     "spatial_and_temporal_locations_of_each_example.csv"
 )
-SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES = ("t0_datetime_UTC", "x_center_OSGB", "y_center_OSGB")
 
 LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR")
diff --git a/nowcasting_dataset/data_sources/data_source.py b/nowcasting_dataset/data_sources/data_source.py
index e065dbe3..3e8c516f 100644
--- a/nowcasting_dataset/data_sources/data_source.py
+++ b/nowcasting_dataset/data_sources/data_source.py
@@ -13,8 +13,8 @@
 import nowcasting_dataset.filesystem.utils as nd_fs_utils
 import nowcasting_dataset.time as nd_time
 from nowcasting_dataset import square, utils
-from nowcasting_dataset.consts import SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES
 from nowcasting_dataset.data_sources.datasource_output import DataSourceOutput
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.dataset.xr_utils import (
     convert_coordinates_to_indexes_for_list_datasets,
     join_list_dataset_to_batch_dataset,
@@ -137,7 +137,7 @@ def open(self):
     @utils.exception_logger
     def create_batches(
         self,
-        spatial_and_temporal_locations_of_each_example: pd.DataFrame,
+        spatial_and_temporal_locations_of_each_example: List[SpaceTimeLocation],
         idx_of_first_batch: int,
         batch_size: int,
         dst_path: Path,
@@ -174,16 +174,6 @@ def create_batches(
         )
         assert upload_every_n_batches >= 0, "`upload_every_n_batches` must be >= 0"
 
-        spatial_and_temporal_locations_of_each_example_columns = (
-            spatial_and_temporal_locations_of_each_example.columns.to_list()
-        )
-        assert spatial_and_temporal_locations_of_each_example_columns == list(
-            SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES
-        ), (
-            f"The provided data columns {spatial_and_temporal_locations_of_each_example_columns}"
-            f" do not match {SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES=}"
-        )
-
         self.open()
 
         # Figure out where to write batches to:
@@ -200,7 +190,7 @@ def create_batches(
                 batch_idx=batch_idx, batch_size=batch_size
             )
 
-            locations_for_batch = spatial_and_temporal_locations_of_each_example.iloc[
+            locations_for_batch = spatial_and_temporal_locations_of_each_example[
                 start_example_idx:end_example_idx
             ]
             locations_for_batches.append(locations_for_batch)
@@ -211,11 +201,7 @@ def create_batches(
             logger.debug(f"{self.__class__.__name__} creating batch {batch_idx}!")
 
             # Generate batch.
-            batch = self.get_batch(
-                t0_datetimes_utc=locations_for_batch.t0_datetime_UTC,
-                x_centers_osgb=locations_for_batch.x_center_OSGB,
-                y_centers_osgb=locations_for_batch.y_center_OSGB,
-            )
+            batch = self.get_batch(locations=locations_for_batch)
 
             # Save batch to disk.
             batch.save_netcdf(
@@ -239,43 +225,26 @@ def create_batches(
                 dst_path=dst_path, local_path=path_to_write_to
             )
 
-    def get_batch(
-        self,
-        t0_datetimes_utc: pd.DatetimeIndex,
-        x_centers_osgb: Iterable[Number],
-        y_centers_osgb: Iterable[Number],
-    ) -> DataSourceOutput:
+    def get_batch(self, locations: List[SpaceTimeLocation]) -> DataSourceOutput:
         """
         Get Batch Data
 
         Args:
-            t0_datetimes_utc: list of timestamps for the datetime of the batches.
-                The batch will also include data for historic and future depending
-                on `history_minutes` and `future_minutes`.
-                The batch size is given by the length of the t0_datetimes.
-            x_centers_osgb: x center batch locations
-            y_centers_osgb: y center batch locations
+            locations: List of locations object
+                A location object contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Batch data.
         """
-        assert len(t0_datetimes_utc) == len(x_centers_osgb), (
-            f"len(t0_datetimes) != len(x_locations): "
-            f"{len(t0_datetimes_utc)} != {len(x_centers_osgb)}"
-        )
-        assert len(t0_datetimes_utc) == len(y_centers_osgb), (
-            f"len(t0_datetimes) != len(y_locations): "
-            f"{len(t0_datetimes_utc)} != {len(y_centers_osgb)}"
-        )
-        zipped = list(zip(t0_datetimes_utc, x_centers_osgb, y_centers_osgb))
-        batch_size = len(t0_datetimes_utc)
+
+        batch_size = len(locations)
 
         with futures.ThreadPoolExecutor(max_workers=batch_size) as executor:
             future_examples = []
-            for coords in zipped:
-                t0_datetime, x_location, y_location = coords
-                future_example = executor.submit(
-                    self.get_example, t0_datetime, x_location, y_location
-                )
+            for location in locations:
+                future_example = executor.submit(self.get_example, location)
                 future_examples.append(future_example)
 
             # Get the examples back.  Loop round each future so we can log a helpful error.
@@ -378,9 +347,7 @@ def _get_time_slice(self, t0_datetime_utc: pd.Timestamp):
 
     def get_example(
         self,
-        t0_datetime_utc: pd.Timestamp,  #: Datetime of "now": The most recent obs.
-        x_center_osgb: Number,  #: Centre, in OSGB coordinates.
-        y_center_osgb: Number,  #: Centre, in OSGB coordinates.
+        location: SpaceTimeLocation,  #: Location object of the most recent observation
     ) -> xr.Dataset:
         """Must be overridden by child classes."""
         raise NotImplementedError()
@@ -452,23 +419,24 @@ def data(self):
             raise RuntimeError("Please run `open()` before accessing data!")
         return self._data
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get Example data
 
         Args:
-            t0_datetime_utc: list of timestamps for the datetime of the batches.
-                The batch will also include data for historic and future depending
-                on `history_minutes` and `future_minutes`.
-            x_center_osgb: x center batch locations
-            y_center_osgb: y center batch locations
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Example Data
 
         """
 
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         logger.debug(
             f"Getting example for {t0_datetime_utc=},  " f"{x_center_osgb=} and  {y_center_osgb=}"
         )
diff --git a/nowcasting_dataset/data_sources/fake/batch.py b/nowcasting_dataset/data_sources/fake/batch.py
index 06daba32..ed461fd1 100644
--- a/nowcasting_dataset/data_sources/fake/batch.py
+++ b/nowcasting_dataset/data_sources/fake/batch.py
@@ -22,7 +22,7 @@
 )
 from nowcasting_dataset.data_sources.gsp.eso import get_gsp_metadata_from_eso
 from nowcasting_dataset.data_sources.gsp.gsp_model import GSP
-from nowcasting_dataset.data_sources.metadata.metadata_model import Metadata
+from nowcasting_dataset.data_sources.metadata.metadata_model import Metadata, SpaceTimeLocation
 from nowcasting_dataset.data_sources.nwp.nwp_model import NWP
 from nowcasting_dataset.data_sources.optical_flow.optical_flow_model import OpticalFlow
 from nowcasting_dataset.data_sources.pv.pv_model import PV
@@ -108,9 +108,9 @@ def gsp_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_datasets = [
@@ -157,13 +157,17 @@ def metadata_fake(
         # choose random index
         index = np.random.choice(len(metadata), size=batch_size)
 
-        lat = metadata.iloc[index].centroid_lat
-        lon = metadata.iloc[index].centroid_lon
+        lat = list(metadata.iloc[index].centroid_lat)
+        lon = list(metadata.iloc[index].centroid_lon)
+        ids = list(metadata.iloc[index].index)
+        id_types = ["gsp"] * batch_size
 
     else:
         # get random OSGB center in the UK
         lat = np.random.uniform(51, 55, batch_size)
         lon = np.random.uniform(-2.5, 1, batch_size)
+        ids = [None] * batch_size
+        id_types = [None] * batch_size
 
     x_centers_osgb, y_centers_osgb = lat_lon_to_osgb(lat=lat, lon=lon)
 
@@ -172,13 +176,19 @@ def metadata_fake(
         batch_size=batch_size, temporally_align_examples=temporally_align_examples
     )
 
-    metadata_dict = {}
-    metadata_dict["batch_size"] = batch_size
-    metadata_dict["x_center_osgb"] = list(x_centers_osgb)
-    metadata_dict["y_center_osgb"] = list(y_centers_osgb)
-    metadata_dict["t0_datetime_utc"] = list(t0_datetimes_utc)
+    # would be good to parrelize this
+    locations = [
+        SpaceTimeLocation(
+            t0_datetime_utc=t0_datetimes_utc[i],
+            x_center_osgb=x_centers_osgb[i],
+            y_center_osgb=y_centers_osgb[i],
+            id=ids[i],
+            id_type=id_types[i],
+        )
+        for i in range(0, batch_size)
+    ]
 
-    return Metadata(**metadata_dict)
+    return Metadata(batch_size=batch_size, space_time_locations=locations)
 
 
 def nwp_fake(
@@ -201,9 +211,9 @@ def nwp_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_arrays = [
@@ -248,9 +258,9 @@ def pv_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_datasets = [
@@ -296,9 +306,9 @@ def satellite_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_arrays = [
@@ -340,9 +350,9 @@ def hrv_satellite_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_arrays = [
@@ -385,9 +395,9 @@ def optical_flow_fake(
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        t0_datetimes_utc = metadata.t0_datetimes_utc
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_arrays = [
@@ -421,7 +431,7 @@ def sun_fake(
     if metadata is None:
         t0_datetimes_utc = make_t0_datetimes_utc(batch_size)
     else:
-        t0_datetimes_utc = metadata.t0_datetime_utc
+        t0_datetimes_utc = metadata.t0_datetimes_utc
 
     # create dataset with both azimuth and elevation, index with time
     # make batch of arrays
@@ -442,8 +452,8 @@ def topographic_fake(batch_size, image_size_pixels, metadata: Optional[Metadata]
     if metadata is None:
         x_centers_osgb, y_centers_osgb = make_random_x_and_y_osgb_centers(batch_size)
     else:
-        x_centers_osgb = metadata.x_center_osgb
-        y_centers_osgb = metadata.y_center_osgb
+        x_centers_osgb = metadata.x_centers_osgb
+        y_centers_osgb = metadata.y_centers_osgb
 
     # make batch of arrays
     xr_arrays = []
diff --git a/nowcasting_dataset/data_sources/gsp/gsp_data_source.py b/nowcasting_dataset/data_sources/gsp/gsp_data_source.py
index 2d57b6c6..6edb11ab 100644
--- a/nowcasting_dataset/data_sources/gsp/gsp_data_source.py
+++ b/nowcasting_dataset/data_sources/gsp/gsp_data_source.py
@@ -7,7 +7,7 @@
 from datetime import datetime
 from numbers import Number
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import List, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -18,6 +18,7 @@
 from nowcasting_dataset.data_sources.data_source import ImageDataSource
 from nowcasting_dataset.data_sources.gsp.eso import get_gsp_metadata_from_eso
 from nowcasting_dataset.data_sources.gsp.gsp_model import GSP
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.geospatial import lat_lon_to_osgb
 from nowcasting_dataset.square import get_bounding_box_mask
 
@@ -130,9 +131,7 @@ def get_number_locations(self):
 
         return len(self.metadata.location_x)
 
-    def get_all_locations(
-        self, t0_datetimes_utc: pd.DatetimeIndex
-    ) -> Tuple[pd.DatetimeIndex, List[Number], List[Number]]:
+    def get_all_locations(self, t0_datetimes_utc: pd.DatetimeIndex) -> List[SpaceTimeLocation]:
         """
         Make locations for all GSP
 
@@ -143,9 +142,11 @@ def get_all_locations(
             t0_datetimes_utc: list of available t0 datetimes.
 
         Returns:
-            1. list of datetimes
-            2. list of x locations
-            3. list of y locations
+            List of space time locations which includes
+            1. datetimes
+            2. x locations
+            3. y locations
+            4. gsp ids
 
         """
 
@@ -163,6 +164,7 @@ def get_all_locations(
             # get all locations
             x_centers_osgb = self.metadata.location_x
             y_centers_osgb = self.metadata.location_y
+            gsp_ids = self.metadata.index
 
             # make x centers
             x_centers_osgb_all_gsps = pd.DataFrame(columns=t0_datetimes_utc, index=x_centers_osgb)
@@ -172,15 +174,36 @@ def get_all_locations(
             y_centers_osgb_all_gsps = pd.DataFrame(columns=t0_datetimes_utc, index=y_centers_osgb)
             y_centers_osgb_all_gsps = y_centers_osgb_all_gsps.unstack().reset_index()
 
+            # make gsp ids
+            gsp_ids = pd.DataFrame(columns=t0_datetimes_utc, index=gsp_ids)
+            gsp_ids = gsp_ids.unstack().reset_index()
+
             t0_datetimes_utc_all_gsps = pd.DatetimeIndex(x_centers_osgb_all_gsps["t0_datetime_utc"])
             x_centers_osgb_all_gsps = list(x_centers_osgb_all_gsps["location_x"])
             y_centers_osgb_all_gsps = list(y_centers_osgb_all_gsps["location_y"])
+            gsp_ids = list(gsp_ids["gsp_id"])
+
+            assert len(x_centers_osgb_all_gsps) == len(y_centers_osgb_all_gsps)
+            assert len(x_centers_osgb_all_gsps) == len(
+                gsp_ids
+            ), f"{len(x_centers_osgb_all_gsps)=} {len(gsp_ids)=}"
+            assert len(y_centers_osgb_all_gsps) == len(gsp_ids)
+
+            locations = []
+            # TODO make dataframe -> List[dict] -> List[Locations]
+            for i in range(len(t0_datetimes_utc_all_gsps)):
+                locations.append(
+                    SpaceTimeLocation(
+                        t0_datetime_utc=t0_datetimes_utc_all_gsps[i],
+                        x_center_osgb=x_centers_osgb_all_gsps[i],
+                        y_center_osgb=y_centers_osgb_all_gsps[i],
+                        id=gsp_ids[i],
+                    )
+                )
 
-            return t0_datetimes_utc_all_gsps, x_centers_osgb_all_gsps, y_centers_osgb_all_gsps
+            return locations
 
-    def get_locations(
-        self, t0_datetimes_utc: pd.DatetimeIndex
-    ) -> Tuple[List[Number], List[Number]]:
+    def get_locations(self, t0_datetimes_utc: pd.DatetimeIndex) -> List[SpaceTimeLocation]:
         """
         Get x and y locations. Assume that all data is available for all GSP.
 
@@ -190,7 +213,7 @@ def get_locations(
         Args:
             t0_datetimes_utc: list of available t0 datetimes.
 
-        Returns: list of x and y locations
+        Returns: list of location objects
 
         """
 
@@ -208,6 +231,7 @@ def get_locations(
             # get x, y locations
             x_centers_osgb = list(metadata.location_x)
             y_centers_osgb = list(metadata.location_y)
+            ids = list(metadata.index)
 
         else:
 
@@ -220,6 +244,7 @@ def get_locations(
             # their geographical location.
             x_centers_osgb = []
             y_centers_osgb = []
+            ids = []
 
             for t0_dt in t0_datetimes_utc:
 
@@ -242,26 +267,47 @@ def get_locations(
                 # Get metadata for GSP
                 x_centers_osgb.append(metadata_for_gsp.location_x)
                 y_centers_osgb.append(metadata_for_gsp.location_y)
+                ids.append(meta_data.index[0])
+
+        assert len(x_centers_osgb) == len(y_centers_osgb)
+        assert len(x_centers_osgb) == len(ids)
+        assert len(y_centers_osgb) == len(ids)
+
+        locations = []
+        for i in range(len(x_centers_osgb)):
+
+            locations.append(
+                SpaceTimeLocation(
+                    t0_datetime_utc=t0_datetimes_utc[i],
+                    x_center_osgb=x_centers_osgb[i],
+                    y_center_osgb=y_centers_osgb[i],
+                    id=ids[i],
+                    id_type="gsp",
+                )
+            )
 
-        return x_centers_osgb, y_centers_osgb
+        return locations
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get data example from one time point (t0_dt) and for x and y coords.
 
         Get data at the location of x,y and get surrounding GSP power data also.
 
         Args:
-            t0_datetime_utc: datetime of "now". History and forecast are also returned
-            x_center_osgb: x location of center GSP.
-            y_center_osgb: y location of center GSP.
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Dictionary with GSP data in it.
         """
         logger.debug("Getting example data")
 
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         # get the GSP power, including history and forecast
         selected_gsp_power, selected_capacity = self._get_time_slice(t0_datetime_utc)
 
diff --git a/nowcasting_dataset/data_sources/metadata/metadata_model.py b/nowcasting_dataset/data_sources/metadata/metadata_model.py
index a0b187e2..80cd2995 100644
--- a/nowcasting_dataset/data_sources/metadata/metadata_model.py
+++ b/nowcasting_dataset/data_sources/metadata/metadata_model.py
@@ -1,52 +1,108 @@
 """ Model for output of general/metadata data, useful for a batch """
 
-from typing import List
+from pathlib import Path
+from typing import List, Optional, Union
 
 import pandas as pd
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 
 from nowcasting_dataset.consts import SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME
 from nowcasting_dataset.filesystem.utils import check_path_exists
 from nowcasting_dataset.utils import get_start_and_end_example_index
 
 
-class Metadata(BaseModel):
-    """Class to store metadata data"""
+class SpaceTimeLocation(BaseModel):
+    """Location of the example"""
 
-    batch_size: int = Field(
+    t0_datetime_utc: pd.Timestamp = Field(
         ...,
-        g=0,
-        description="The size of this batch. If the batch size is 0, "
-        "then this item stores one data item",
+        description="The t0 of one example ",
     )
 
-    t0_datetime_utc: List[pd.Timestamp] = Field(
+    x_center_osgb: float = Field(
         ...,
-        description="The t0s of each example ",
+        description="The x center of one example in OSGB coordinates",
     )
 
-    x_center_osgb: List[int] = Field(
+    y_center_osgb: float = Field(
         ...,
-        description="The x centers of each example in OSGB coordinates",
+        description="The y center of one example in OSGB coordinates",
+    )
+
+    id: Optional[int] = Field(
+        None,
+        description="The id of the GSP or the PV system. This is optional so can be None",
     )
 
-    y_center_osgb: List[int] = Field(
+    id_type: Optional[str] = Field(
+        None,
+        description="The type of the id. Should be either None, 'gsp' or 'pv_system'",
+    )
+
+    @validator("t0_datetime_utc")
+    def v_t0_datetime_utc(cls, t0_datetime_utc):
+        """Make sure t0_datetime_utc is pandas Timestamp"""
+        return pd.Timestamp(t0_datetime_utc)
+
+    @validator("id_type")
+    def v_id_type(cls, id_type):
+        """Make sure id_type is either None, 'gsp' or 'pv_system'"""
+
+        if id_type == "None":
+            id_type = None
+
+        assert id_type in [
+            None,
+            "gsp",
+            "pv_system",
+        ], f"{id_type=} should be None, 'gsp' or 'pv_system'"
+        return id_type
+
+
+class Metadata(BaseModel):
+    """Class to store metadata data"""
+
+    batch_size: int = Field(
         ...,
-        description="The y centers of each example in OSGB coordinates",
+        g=0,
+        description="The size of this batch. If the batch size is 0, "
+        "then this item stores one data item",
     )
 
+    space_time_locations: List[SpaceTimeLocation]
+
+    @property
+    def t0_datetimes_utc(self) -> list:
+        """Return all the t0"""
+        return [location.t0_datetime_utc for location in self.space_time_locations]
+
+    @property
+    def x_centers_osgb(self) -> List[float]:
+        """List of all the x centers from all the locations"""
+        return [location.x_center_osgb for location in self.space_time_locations]
+
+    @property
+    def y_centers_osgb(self) -> List[float]:
+        """List of all the x centers from all the locations"""
+        return [location.y_center_osgb for location in self.space_time_locations]
+
+    @property
+    def ids(self) -> List[float]:
+        """List of all the ids from all the locations"""
+        return [location.id for location in self.space_time_locations]
+
     def save_to_csv(self, path):
         """
         Save metadata to a csv file
 
         Args:
-            path: the path where the file shold be save
+            path: the path where the file should be save
 
         """
 
         filename = f"{path}/{SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME}"
-        metadata_dict = self.dict()
-        metadata_dict.pop("batch_size")
+        metadata_dict = [location.dict() for location in self.space_time_locations]
+        # metadata_dict.pop("batch_size")
 
         # if file exists, add to it
         try:
@@ -64,7 +120,9 @@ def save_to_csv(self, path):
         metadata_df.to_csv(filename, index=False)
 
 
-def load_from_csv(path, batch_idx, batch_size) -> Metadata:
+def load_from_csv(
+    path: Union[str, Path], batch_size: int, batch_idx: Optional[int] = None
+) -> Metadata:
     """
     Load metadata from csv
 
@@ -78,17 +136,26 @@ def load_from_csv(path, batch_idx, batch_size) -> Metadata:
     filename = f"{path}/{SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME}"
 
     # get start and end example index
-    start_example_idx, end_example_idx = get_start_and_end_example_index(
-        batch_idx=batch_idx, batch_size=batch_size
-    )
-
-    names = ["t0_datetime_utc", "x_center_osgb", "y_center_osgb"]
+    if batch_idx is not None:
+        start_example_idx, end_example_idx = get_start_and_end_example_index(
+            batch_idx=batch_idx, batch_size=batch_size
+        )
+        skiprows = start_example_idx + 1  # p+1 is to ignore header
+        nrows = batch_size
+    else:
+        skiprows = 1  # ignore header
+        nrows = None
+
+    names = list(SpaceTimeLocation.__fields__)
 
     # read the file
+    # kswargs = {}
+    # if (start_example_idx is not None) and (end_example_idx is not None):
+    #     kswargs['nrows'] = batch_size
     metadata_df = pd.read_csv(
         filename,
-        skiprows=start_example_idx + 1,  # p+1 is to ignore header
-        nrows=batch_size,
+        skiprows=skiprows,
+        nrows=nrows,
         names=names,
     )
 
@@ -96,8 +163,10 @@ def load_from_csv(path, batch_idx, batch_size) -> Metadata:
         len(metadata_df) > 0
     ), f"Could not load metadata for {batch_size=} {batch_idx=} {filename=}"
 
+    metadata_df["id_type"].fillna("None", inplace=True)
+
     # add batch_size
-    metadata_dict = metadata_df.to_dict("list")
-    metadata_dict["batch_size"] = batch_size
+    locations_dict = metadata_df.to_dict("records")
+    metadata_dict = {"space_time_locations": locations_dict, "batch_size": batch_size}
 
     return Metadata(**metadata_dict)
diff --git a/nowcasting_dataset/data_sources/optical_flow/optical_flow_data_source.py b/nowcasting_dataset/data_sources/optical_flow/optical_flow_data_source.py
index 1b0dae0b..99d005eb 100644
--- a/nowcasting_dataset/data_sources/optical_flow/optical_flow_data_source.py
+++ b/nowcasting_dataset/data_sources/optical_flow/optical_flow_data_source.py
@@ -1,7 +1,6 @@
 """ Optical Flow Data Source """
 import logging
 from dataclasses import dataclass
-from numbers import Number
 from pathlib import Path
 from typing import Iterable, Union
 
@@ -12,6 +11,7 @@
 
 import nowcasting_dataset.filesystem.utils as nd_fs_utils
 from nowcasting_dataset.data_sources import DataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.optical_flow.format_images import crop_center, remap_image
 from nowcasting_dataset.data_sources.optical_flow.optical_flow_model import OpticalFlow
 from nowcasting_dataset.dataset.xr_utils import convert_arrays_to_uint8
@@ -104,27 +104,23 @@ def open(self):
         """Open the underlying self.source_data_source."""
         self.source_data_source.open()
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get Optical Flow Example data
 
         Args:
-            t0_datetime_utc: list of timestamps for the datetime of the batches.
-                The batch will also include data for historic and future depending
-                on `history_minutes` and `future_minutes`.
-            x_center_osgb: x center batch locations
-            y_center_osgb: y center batch locations
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Example Data
 
         """
+
         assert self.source_data_source.sample_period_minutes == self.sample_period_minutes
         satellite_data: xr.Dataset = self.source_data_source.get_example(
-            t0_datetime_utc=t0_datetime_utc,
-            x_center_osgb=x_center_osgb,
-            y_center_osgb=y_center_osgb,
+            location=location,
         )
         satellite_data = satellite_data["data"]
         optical_flow_data_array = self._compute_and_return_optical_flow(satellite_data)
diff --git a/nowcasting_dataset/data_sources/pv/pv_data_source.py b/nowcasting_dataset/data_sources/pv/pv_data_source.py
index 49880410..e911ab55 100644
--- a/nowcasting_dataset/data_sources/pv/pv_data_source.py
+++ b/nowcasting_dataset/data_sources/pv/pv_data_source.py
@@ -18,6 +18,7 @@
 from nowcasting_dataset import geospatial
 from nowcasting_dataset.consts import DEFAULT_N_PV_SYSTEMS_PER_EXAMPLE
 from nowcasting_dataset.data_sources.data_source import ImageDataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.pv.pv_model import PV
 from nowcasting_dataset.square import get_bounding_box_mask, get_closest_coordinate_order
 
@@ -224,24 +225,25 @@ def _get_all_pv_system_ids_in_roi(
 
         return pv_system_ids
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get Example data for PV data
 
         Args:
-            t0_datetime_utc: list of timestamps for the datetime of the batches.
-                The batch will also include data for historic and future depending
-                on 'history_minutes' and 'future_minutes'.
-            x_center_osgb: x center batch locations
-            y_center_osgb: y center batch locations
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Example data
 
         """
         logger.debug("Getting PV example data")
 
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         selected_pv_power, selected_pv_capacity = self._get_time_slice(t0_datetime_utc)
         all_pv_system_ids = self._get_all_pv_system_ids_in_roi(
             x_center_osgb, y_center_osgb, selected_pv_power.columns
@@ -314,9 +316,7 @@ def get_example(
 
         return pv
 
-    def get_locations(
-        self, t0_datetimes_utc: pd.DatetimeIndex
-    ) -> Tuple[List[Number], List[Number]]:
+    def get_locations(self, t0_datetimes_utc: pd.DatetimeIndex) -> List[SpaceTimeLocation]:
         """Find a valid geographical location for each t0_datetime.
 
         Returns:  x_locations, y_locations. Each has one entry per t0_datetime.
@@ -335,18 +335,25 @@ def _get_pv_system_ids(t0_datetime: pd.Timestamp) -> pd.Int64Index:
 
         # Pick a random PV system for each t0_datetime, and then grab
         # their geographical location.
-        x_locations = []
-        y_locations = []
+        locations = []
         for t0_datetime in t0_datetimes_utc:
             pv_system_ids = _get_pv_system_ids(t0_datetime)
             pv_system_id = self.rng.choice(pv_system_ids)
 
             # Get metadata for PV system
             metadata_for_pv_system = self.pv_metadata.loc[pv_system_id]
-            x_locations.append(metadata_for_pv_system.location_x)
-            y_locations.append(metadata_for_pv_system.location_y)
 
-        return x_locations, y_locations
+            locations.append(
+                SpaceTimeLocation(
+                    t0_datetime_utc=t0_datetime,
+                    x_center_osgb=metadata_for_pv_system.location_x,
+                    y_center_osgb=metadata_for_pv_system.location_y,
+                    id=pv_system_id,
+                    id_type="pv_system",
+                )
+            )
+
+        return locations
 
     def datetime_index(self) -> pd.DatetimeIndex:
         """Returns a complete list of all available datetimes."""
diff --git a/nowcasting_dataset/data_sources/satellite/satellite_data_source.py b/nowcasting_dataset/data_sources/satellite/satellite_data_source.py
index 05423213..67edad23 100644
--- a/nowcasting_dataset/data_sources/satellite/satellite_data_source.py
+++ b/nowcasting_dataset/data_sources/satellite/satellite_data_source.py
@@ -16,6 +16,7 @@
 import nowcasting_dataset.time as nd_time
 from nowcasting_dataset.consts import SAT_VARIABLE_NAMES
 from nowcasting_dataset.data_sources.data_source import ZarrDataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.satellite.satellite_model import Satellite
 from nowcasting_dataset.geospatial import OSGB
 from nowcasting_dataset.utils import drop_duplicate_times, drop_non_monotonic_increasing
@@ -197,22 +198,23 @@ def get_spatial_region_of_interest(
         )
         return data_array
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get Example data
 
         Args:
-            t0_datetime_utc: list of timestamps for the datetime of the batches.
-                The batch will also include data for historic and future depending
-                on `history_minutes` and `future_minutes`.
-            x_center_osgb: x center batch locations
-            y_center_osgb: y center batch locations
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Example Data
 
         """
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         selected_data = self._get_time_slice(t0_datetime_utc)
         selected_data = self.get_spatial_region_of_interest(
             data_array=selected_data,
diff --git a/nowcasting_dataset/data_sources/sun/sun_data_source.py b/nowcasting_dataset/data_sources/sun/sun_data_source.py
index 2e2e4777..6a045793 100644
--- a/nowcasting_dataset/data_sources/sun/sun_data_source.py
+++ b/nowcasting_dataset/data_sources/sun/sun_data_source.py
@@ -11,6 +11,7 @@
 
 import nowcasting_dataset.filesystem.utils as nd_fs_utils
 from nowcasting_dataset.data_sources.data_source import DataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.sun.raw_data_load_save import load_from_zarr, x_y_to_name
 from nowcasting_dataset.data_sources.sun.sun_model import Sun
 from nowcasting_dataset.geospatial import calculate_azimuth_and_elevation_angle
@@ -38,22 +39,26 @@ def check_input_paths_exist(self) -> None:
         """Check input paths exist.  If not, raise a FileNotFoundError."""
         nd_fs_utils.check_path_exists(self.zarr_path)
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get example data from t0_dt and x and y xoordinates
 
         Args:
-            t0_datetime_utc: the timestamp to get the sun data for
-            x_center_osgb: the x coordinate (OSGB)
-            y_center_osgb: the y coordinate (OSGB)
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns: Dictionary of azimuth and elevation data
         """
         # all sun data is from 2019, analaysis showed over the timescale we are interested in the
         # elevation and azimuth angles change by < 1 degree, so to save data, we just use data
         # from 2019.
+
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         t0_datetime_utc = t0_datetime_utc.replace(year=2019)
 
         start_dt = self._get_start_dt(t0_datetime_utc)
diff --git a/nowcasting_dataset/data_sources/topographic/topographic_data_source.py b/nowcasting_dataset/data_sources/topographic/topographic_data_source.py
index f0a8e2ea..6d2914ce 100644
--- a/nowcasting_dataset/data_sources/topographic/topographic_data_source.py
+++ b/nowcasting_dataset/data_sources/topographic/topographic_data_source.py
@@ -1,7 +1,6 @@
 """ Topological DataSource """
 import logging
 from dataclasses import dataclass
-from numbers import Number
 
 import pandas as pd
 import rioxarray
@@ -10,6 +9,7 @@
 
 import nowcasting_dataset.filesystem.utils as nd_fs_utils
 from nowcasting_dataset.data_sources.data_source import ImageDataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.topographic.topographic_model import Topographic
 from nowcasting_dataset.geospatial import OSGB
 from nowcasting_dataset.utils import OpenData
@@ -57,20 +57,24 @@ def check_input_paths_exist(self) -> None:
         """Check input paths exist.  If not, raise a FileNotFoundError."""
         nd_fs_utils.check_path_exists(self.filename)
 
-    def get_example(
-        self, t0_datetime_utc: pd.Timestamp, x_center_osgb: Number, y_center_osgb: Number
-    ) -> xr.Dataset:
+    def get_example(self, location: SpaceTimeLocation) -> xr.Dataset:
         """
         Get a single example
 
         Args:
-            t0_datetime_utc: Current datetime for the example, unused
-            x_center_osgb: Center of the example in meters in the x direction in OSGB coordinates
-            y_center_osgb: Center of the example in meters in the y direction in OSGB coordinates
+            location: A location object of the example which contains
+                - a timestamp of the example (t0_datetime_utc),
+                - the x center location of the example (x_location_osgb)
+                - the y center location of the example(y_location_osgb)
 
         Returns:
             Example containing topographic data for the selected area
         """
+
+        t0_datetime_utc = location.t0_datetime_utc
+        x_center_osgb = location.x_center_osgb
+        y_center_osgb = location.y_center_osgb
+
         bounding_box = self._square.bounding_box_centered_on(
             x_center_osgb=x_center_osgb, y_center_osgb=y_center_osgb
         )
diff --git a/nowcasting_dataset/manager/base.py b/nowcasting_dataset/manager/base.py
index 14c38f51..5b915c3b 100644
--- a/nowcasting_dataset/manager/base.py
+++ b/nowcasting_dataset/manager/base.py
@@ -6,7 +6,6 @@
 
 import nowcasting_dataset.utils as nd_utils
 from nowcasting_dataset import config
-from nowcasting_dataset.consts import SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME
 from nowcasting_dataset.data_sources import ALL_DATA_SOURCE_NAMES, MAP_DATA_SOURCE_NAME_TO_CLASS
 
 logger = logging.getLogger(__name__)
@@ -110,8 +109,4 @@ def _locations_csv_file_exists(self):
         return False
 
     def _filename_of_locations_csv_file(self, split_name: str) -> Path:
-        return (
-            self.config.output_data.filepath
-            / split_name
-            / SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME
-        )
+        return self.config.output_data.filepath / split_name
diff --git a/nowcasting_dataset/manager/manager.py b/nowcasting_dataset/manager/manager.py
index 092016e9..c4bc2bbd 100644
--- a/nowcasting_dataset/manager/manager.py
+++ b/nowcasting_dataset/manager/manager.py
@@ -3,7 +3,7 @@
 import logging
 import multiprocessing
 from functools import partial
-from typing import Optional, Union
+from typing import List, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -11,11 +11,13 @@
 import nowcasting_dataset.time as nd_time
 import nowcasting_dataset.utils as nd_utils
 from nowcasting_dataset import config
-from nowcasting_dataset.consts import (
-    SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES,
-    SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME,
-)
+from nowcasting_dataset.consts import SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME
 from nowcasting_dataset.data_sources import ALL_DATA_SOURCE_NAMES
+from nowcasting_dataset.data_sources.metadata.metadata_model import (
+    Metadata,
+    SpaceTimeLocation,
+    load_from_csv,
+)
 from nowcasting_dataset.dataset.split import split
 from nowcasting_dataset.filesystem import utils as nd_fs_utils
 from nowcasting_dataset.manager.base import ManagerBase
@@ -144,16 +146,20 @@ def create_files_specifying_spatial_and_temporal_locations_of_each_example_if_ne
             else:
                 get_all_locations = False
 
-            df_of_locations = self.sample_spatial_and_temporal_locations_for_examples(
+            locations = self.sample_spatial_and_temporal_locations_for_examples(
                 t0_datetimes=datetimes_for_split,
                 n_examples=n_examples,
                 get_all_locations=get_all_locations,
             )
-            output_filename = self._filename_of_locations_csv_file(split_name)
+            metadata = Metadata(
+                batch_size=self.config.process.batch_size, space_time_locations=locations
+            )
+            # output_filename = self._filename_of_locations_csv_file(split_name)
             logger.info(f"Making {path_for_csv} if it does not exist.")
             nd_fs_utils.makedirs(path_for_csv, exist_ok=True)
-            logger.debug(f"Writing {output_filename}")
-            df_of_locations.to_csv(output_filename)
+            # logger.debug(f"Writing {output_filename}")
+            logger.debug(f"Saving {len(metadata.space_time_locations)} locations to csv")
+            metadata.save_to_csv(path_for_csv)
 
     def _get_n_batches_requested_for_split_name(self, split_name: str) -> int:
         return getattr(self.config.process, f"n_{split_name}_batches")
@@ -223,7 +229,7 @@ def get_t0_datetimes_across_all_data_sources(
 
     def sample_spatial_and_temporal_locations_for_examples(
         self, t0_datetimes: pd.DatetimeIndex, n_examples: int, get_all_locations: bool = False
-    ) -> pd.DataFrame:
+    ) -> List[SpaceTimeLocation]:
         """
         Computes the geospatial and temporal locations for each training example.
 
@@ -267,30 +273,17 @@ def sample_spatial_and_temporal_locations_for_examples(
 
             # note that the returned 'shuffled_t0_datetimes'
             # has duplicate datetimes for each location
-            (
-                shuffled_t0_datetimes,
-                x_locations,
-                y_locations,
-            ) = self.data_source_which_defines_geospatial_locations.get_all_locations(
+            locations = self.data_source_which_defines_geospatial_locations.get_all_locations(
                 t0_datetimes_utc=shuffled_t0_datetimes
             )
 
         else:
 
-            (
-                x_locations,
-                y_locations,
-            ) = self.data_source_which_defines_geospatial_locations.get_locations(
+            locations = self.data_source_which_defines_geospatial_locations.get_locations(
                 shuffled_t0_datetimes
             )
 
-        return pd.DataFrame(
-            {
-                "t0_datetime_UTC": shuffled_t0_datetimes,
-                "x_center_OSGB": x_locations,
-                "y_center_OSGB": y_locations,
-            }
-        )
+        return locations
 
     def _get_first_batches_to_create(
         self, overwrite_batches: bool
@@ -381,19 +374,18 @@ def create_batches(self, overwrite_batches: bool) -> None:
                 return
 
         # Load locations for each example off disk.
-        locations_for_each_example_of_each_split: dict[split.SplitName, pd.DataFrame] = {}
+        locations_for_each_example_of_each_split: dict[
+            split.SplitName, List[SpaceTimeLocation]
+        ] = {}
         for split_name in splits_which_need_more_batches:
             filename = self._filename_of_locations_csv_file(split_name.value)
             logger.info(f"Loading {filename}.")
-            locations_for_each_example = pd.read_csv(filename, index_col=0)
-            assert locations_for_each_example.columns.to_list() == list(
-                SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES
-            )
-            # Converting to datetimes is much faster using `pd.to_datetime()` than
-            # passing `parse_datetimes` into `pd.read_csv()`.
-            locations_for_each_example["t0_datetime_UTC"] = pd.to_datetime(
-                locations_for_each_example["t0_datetime_UTC"]
-            )
+
+            metadata = load_from_csv(path=filename, batch_size=self.config.process.batch_size)
+            locations_for_each_example = metadata.space_time_locations
+
+            logger.debug(f"Got {len(locations_for_each_example)} locations")
+
             if len(locations_for_each_example) > 0:
                 locations_for_each_example_of_each_split[split_name] = locations_for_each_example
 
@@ -413,7 +405,7 @@ def create_batches(self, overwrite_batches: bool) -> None:
                     # Get indexes of first batch and example. And subset locations_for_split.
                     idx_of_first_batch = first_batches_to_create[split_name][data_source_name]
                     idx_of_first_example = idx_of_first_batch * self.config.process.batch_size
-                    locations = locations_for_split.loc[idx_of_first_example:]
+                    locations = locations_for_split[idx_of_first_example:]
 
                     # Get paths.
                     dst_path = (
diff --git a/nowcasting_dataset/manager/manager_live.py b/nowcasting_dataset/manager/manager_live.py
index cec339eb..cb84818f 100644
--- a/nowcasting_dataset/manager/manager_live.py
+++ b/nowcasting_dataset/manager/manager_live.py
@@ -4,6 +4,7 @@
 import multiprocessing
 from datetime import datetime
 from functools import partial
+from typing import List
 
 import numpy as np
 import pandas as pd
@@ -11,9 +12,13 @@
 import nowcasting_dataset.utils as nd_utils
 from nowcasting_dataset.consts import (
     N_GSPS,
-    SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES,
     SPATIAL_AND_TEMPORAL_LOCATIONS_OF_EACH_EXAMPLE_FILENAME,
 )
+from nowcasting_dataset.data_sources.metadata.metadata_model import (
+    Metadata,
+    SpaceTimeLocation,
+    load_from_csv,
+)
 from nowcasting_dataset.filesystem import utils as nd_fs_utils
 from nowcasting_dataset.manager.base import ManagerBase
 from nowcasting_dataset.manager.utils import callback, error_callback
@@ -70,18 +75,21 @@ def create_files_specifying_spatial_and_temporal_locations_of_each_example(
             f" examples per batch = {n_examples:,d} examples for {split_name}."
         )
 
-        df_of_locations = self.sample_spatial_and_temporal_locations_for_examples(
+        locations = self.sample_spatial_and_temporal_locations_for_examples(
             t0_datetime=datetimes_for_split[0],
         )
-        output_filename = self._filename_of_locations_csv_file(split_name="live")
+        metadata = Metadata(
+            batch_size=self.config.process.batch_size, space_time_locations=locations
+        )
+        # output_filename = self._filename_of_locations_csv_file(split_name="live")
         logger.info(f"Making {path_for_csv} if it does not exist.")
         nd_fs_utils.makedirs(path_for_csv, exist_ok=True)
-        logger.debug(f"Writing {output_filename}")
-        df_of_locations.to_csv(output_filename)
+        logger.debug(f"Writing {path_for_csv}")
+        metadata.save_to_csv(path_for_csv)
 
     def sample_spatial_and_temporal_locations_for_examples(
         self, t0_datetime: datetime
-    ) -> pd.DataFrame:
+    ) -> List[SpaceTimeLocation]:
         """
         Computes the geospatial and temporal locations for each training example.
 
@@ -101,18 +109,15 @@ def sample_spatial_and_temporal_locations_for_examples(
 
         # note that the returned 'shuffled_t0_datetimes'
         # has duplicate datetimes for each location
-        (
-            shuffled_t0_datetimes,
-            x_locations,
-            y_locations,
-        ) = self.data_source_which_defines_geospatial_locations.get_all_locations(
+        locations: List[
+            SpaceTimeLocation
+        ] = self.data_source_which_defines_geospatial_locations.get_all_locations(
             t0_datetimes_utc=pd.DatetimeIndex([t0_datetime])
         )
-        shuffled_t0_datetimes = list(shuffled_t0_datetimes)
 
         # find out the number of examples in the last batch,
         # we maybe need to duplicate the last example into order to get a full batch
-        n_examples_last_batch = len(shuffled_t0_datetimes) % self.config.process.batch_size
+        n_examples_last_batch = len(locations) % self.config.process.batch_size
         # Note 0 means the examples fit into the batches
 
         if n_examples_last_batch != 0:
@@ -121,17 +126,16 @@ def sample_spatial_and_temporal_locations_for_examples(
             # but this keeps it pretty simple for the moment
             extra_examples_needed = self.config.process.batch_size - n_examples_last_batch
             for _ in range(0, extra_examples_needed):
-                shuffled_t0_datetimes.append(shuffled_t0_datetimes[0])
-                x_locations.append(x_locations[0])
-                y_locations.append(y_locations[0])
-
-        return pd.DataFrame(
-            {
-                "t0_datetime_UTC": shuffled_t0_datetimes,
-                "x_center_OSGB": x_locations,
-                "y_center_OSGB": y_locations,
-            }
-        )
+                locations.append(
+                    SpaceTimeLocation(
+                        t0_datetime_utc=locations[0].t0_datetime_utc,
+                        x_center_osgb=locations[0].x_center_osgb,
+                        y_center_osgb=locations[0].y_center_osgb,
+                        id=locations[0].id,
+                    )
+                )
+
+        return locations
 
     def create_batches(self) -> None:
         """Create batches (if necessary).
@@ -150,15 +154,8 @@ def create_batches(self) -> None:
         logger.info(f"Loading {filename}.")
 
         # TODO add pydantic model for this
-        locations_for_each_example = pd.read_csv(filename, index_col=0)
-        assert locations_for_each_example.columns.to_list() == list(
-            SPATIAL_AND_TEMPORAL_LOCATIONS_COLUMN_NAMES
-        )
-        # Converting to datetimes is much faster using `pd.to_datetime()` than
-        # passing `parse_datetimes` into `pd.read_csv()`.
-        locations_for_each_example["t0_datetime_UTC"] = pd.to_datetime(
-            locations_for_each_example["t0_datetime_UTC"]
-        )
+        metadata = load_from_csv(path=filename, batch_size=self.config.process.batch_size)
+        locations_for_each_example = metadata.space_time_locations
 
         # Fire up a separate process for each DataSource, and pass it a list of batches to
         # create, and whether to utils.upload_and_delete_local_files().
diff --git a/tests/data_sources/fake/test_fake.py b/tests/data_sources/fake/test_fake.py
index e3426a2d..8f147a95 100644
--- a/tests/data_sources/fake/test_fake.py
+++ b/tests/data_sources/fake/test_fake.py
@@ -21,7 +21,7 @@ def test_metadata_fake():
     """Test get fake metadata not on gsp centers"""
     m = metadata_fake(batch_size=8, use_gsp_centers=False)
 
-    assert len(m.t0_datetime_utc) == 8
+    assert len(m.t0_datetimes_utc) == 8
 
 
 def test_metadata_fake_gsp():
@@ -33,8 +33,8 @@ def test_metadata_fake_gsp():
     metadata["location_x"], metadata["location_y"] = lat_lon_to_osgb(
         lat=metadata["centroid_lat"], lon=metadata["centroid_lon"]
     )
-    assert m.x_center_osgb[0] in metadata["location_x"].astype(int).values
-    assert m.y_center_osgb[0] in metadata["location_y"].astype(int).values
+    assert m.x_centers_osgb[0] in metadata["location_x"].values
+    assert m.y_centers_osgb[0] in metadata["location_y"].values
 
 
 def test_model(configuration):  # noqa: D103
@@ -46,9 +46,9 @@ def test_model(configuration):  # noqa: D103
     t0_index_gsp = configuration.input_data.gsp.history_seq_length_30_minutes
     t0_index_satellite = configuration.input_data.satellite.history_seq_length_5_minutes
 
-    t0_datetimes_utc = batch.metadata.t0_datetime_utc
-    x_center_osgb = batch.metadata.x_center_osgb
-    y_center_osgb = batch.metadata.y_center_osgb
+    t0_datetimes_utc = batch.metadata.t0_datetimes_utc
+    x_center_osgb = batch.metadata.x_centers_osgb
+    y_center_osgb = batch.metadata.y_centers_osgb
 
     assert batch.gsp.time[0, t0_index_gsp] == t0_datetimes_utc[0]
     assert batch.satellite.time[0, t0_index_satellite] == t0_datetimes_utc[0]
diff --git a/tests/data_sources/gsp/test_gsp_data_source.py b/tests/data_sources/gsp/test_gsp_data_source.py
index b5cea8ee..51a8694c 100644
--- a/tests/data_sources/gsp/test_gsp_data_source.py
+++ b/tests/data_sources/gsp/test_gsp_data_source.py
@@ -9,6 +9,7 @@
     GSPDataSource,
     drop_gsp_north_of_boundary,
 )
+from nowcasting_dataset.data_sources.metadata.metadata_model import Metadata
 from nowcasting_dataset.geospatial import osgb_to_lat_lon
 
 
@@ -41,19 +42,18 @@ def test_gsp_pv_data_source_get_locations():
         meters_per_pixel=2000,
     )
 
-    locations_x, locations_y = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[0:10])
+    locations = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[0:10])
 
-    assert len(locations_x) == len(locations_y)
     # This makes sure it is not in lat/lon.
     # Note that OSGB could be <= than 90, but that would mean a location in the middle of the sea,
     # which is impossible for GSP data
-    assert locations_x[0] > 90
-    assert locations_y[0] > 90
+    assert locations[0].x_center_osgb > 90
+    assert locations[0].y_center_osgb > 90
 
-    lat, lon = osgb_to_lat_lon(locations_x, locations_y)
+    lat, lon = osgb_to_lat_lon(locations[0].x_center_osgb, locations[0].y_center_osgb)
 
-    assert 0 < lat[0] < 90  # this makes sure it is in lat/lon
-    assert -90 < lon[0] < 90  # this makes sure it is in lat/lon
+    assert 0 < lat < 90  # this makes sure it is in lat/lon
+    assert -90 < lon < 90  # this makes sure it is in lat/lon
 
 
 def test_gsp_pv_data_source_get_all_locations():
@@ -75,27 +75,24 @@ def test_gsp_pv_data_source_get_all_locations():
     t0_datetimes_utc = gsp.gsp_power.index[0:10]
     x_locations = gsp.metadata.location_x
 
-    (
-        t0_datetimes_utc_all_gsps,
-        x_centers_osgb_all_gsps,
-        y_centers_osgb_all_gsps,
-    ) = gsp.get_all_locations(t0_datetimes_utc=t0_datetimes_utc)
-
-    assert len(t0_datetimes_utc_all_gsps) == len(x_centers_osgb_all_gsps)
-    assert len(t0_datetimes_utc_all_gsps) == len(y_centers_osgb_all_gsps)
-    assert len(t0_datetimes_utc_all_gsps) == len(x_locations) * len(t0_datetimes_utc)
+    locations = gsp.get_all_locations(t0_datetimes_utc=t0_datetimes_utc)
+    metadata = Metadata(space_time_locations=locations, batch_size=32)
 
     # check first few are the same datetime
-    assert (x_centers_osgb_all_gsps[0:N_gsps] == x_locations.values).all()
-    assert (t0_datetimes_utc_all_gsps[0:N_gsps] == t0_datetimes_utc[0]).all()
+    assert (metadata.x_centers_osgb[0:N_gsps] == x_locations.values).all()
+    assert (pd.DatetimeIndex(metadata.t0_datetimes_utc[0:N_gsps]) == t0_datetimes_utc[0]).all()
 
     # check second set of datetimes
-    assert (x_centers_osgb_all_gsps[N_gsps : 2 * N_gsps] == x_locations.values).all()
-    assert (t0_datetimes_utc_all_gsps[N_gsps : 2 * N_gsps] == t0_datetimes_utc[1]).all()
+    assert (metadata.x_centers_osgb[N_gsps : 2 * N_gsps] == x_locations.values).all()
+    assert (
+        pd.DatetimeIndex(metadata.t0_datetimes_utc[N_gsps : 2 * N_gsps]) == t0_datetimes_utc[1]
+    ).all()
 
     # check all datetimes
-    t0_datetimes_utc_all_gsps_overlap = t0_datetimes_utc_all_gsps.union(t0_datetimes_utc)
-    assert len(t0_datetimes_utc_all_gsps_overlap) == len(t0_datetimes_utc_all_gsps)
+    t0_datetimes_utc_all_gsps_overlap = pd.DatetimeIndex(metadata.t0_datetimes_utc).union(
+        t0_datetimes_utc
+    )
+    assert len(t0_datetimes_utc_all_gsps_overlap) == len(metadata.t0_datetimes_utc)
 
 
 def test_gsp_pv_data_source_get_example():
@@ -115,12 +112,8 @@ def test_gsp_pv_data_source_get_example():
         meters_per_pixel=2000,
     )
 
-    x_locations, y_locations = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[0:10])
-    example = gsp.get_example(
-        t0_datetime_utc=gsp.gsp_power.index[0],
-        x_center_osgb=x_locations[0],
-        y_center_osgb=y_locations[0],
-    )
+    locations = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[0:10])
+    example = gsp.get_example(location=locations[0])
 
     assert len(example.id) == len(example.power_mw[0])
     assert len(example.x_osgb) == len(example.y_osgb)
@@ -145,13 +138,9 @@ def test_gsp_pv_data_source_get_batch():
 
     batch_size = 10
 
-    x_locations, y_locations = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[0:batch_size])
+    locations = gsp.get_locations(t0_datetimes_utc=gsp.gsp_power.index[batch_size : 2 * batch_size])
 
-    batch = gsp.get_batch(
-        t0_datetimes_utc=gsp.gsp_power.index[batch_size : 2 * batch_size],
-        x_centers_osgb=x_locations[0:batch_size],
-        y_centers_osgb=y_locations[0:batch_size],
-    )
+    batch = gsp.get_batch(locations=locations[:batch_size])
 
     assert len(batch.power_mw[0]) == 4
     assert len(batch.id[0]) == len(batch.x_osgb[0])
diff --git a/tests/data_sources/optical_flow/test_optical_flow_data_source.py b/tests/data_sources/optical_flow/test_optical_flow_data_source.py
index fb3be923..1ed417be 100644
--- a/tests/data_sources/optical_flow/test_optical_flow_data_source.py
+++ b/tests/data_sources/optical_flow/test_optical_flow_data_source.py
@@ -5,6 +5,7 @@
 import pytest
 
 from nowcasting_dataset.config.model import Configuration, InputData
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.optical_flow.optical_flow_data_source import (
     OpticalFlowDataSource,
 )
@@ -47,6 +48,8 @@ def test_optical_flow_get_example(
     optical_flow_datasource.open()
     t0_dt = pd.Timestamp("2020-04-01T13:00")
     example = optical_flow_datasource.get_example(
-        t0_datetime_utc=t0_dt, x_center_osgb=10_000, y_center_osgb=10_000
+        location=SpaceTimeLocation(
+            t0_datetime_utc=t0_dt, x_center_osgb=10_000, y_center_osgb=10_000
+        )
     )
     assert example["data"].shape == (n_seq, 32, 32, 1)  # timesteps, height, width, channels
diff --git a/tests/data_sources/satellite/test_satellite_data_source.py b/tests/data_sources/satellite/test_satellite_data_source.py
index 76965949..2e0b5b13 100644
--- a/tests/data_sources/satellite/test_satellite_data_source.py
+++ b/tests/data_sources/satellite/test_satellite_data_source.py
@@ -3,6 +3,7 @@
 import pandas as pd
 import pytest
 
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.satellite.satellite_data_source import SatelliteDataSource
 
 
@@ -39,7 +40,9 @@ def _test_get_example(
     data_source.open()
     t0_dt = pd.Timestamp("2020-04-01T13:00")
     sat_data = data_source.get_example(
-        t0_datetime_utc=t0_dt, x_center_osgb=x_center_osgb, y_center_osgb=y_center_osgb
+        SpaceTimeLocation(
+            t0_datetime_utc=t0_dt, x_center_osgb=x_center_osgb, y_center_osgb=y_center_osgb
+        )
     )
 
     # sat_data.y is top-to-bottom.
diff --git a/tests/data_sources/sun/test_sun_data_source.py b/tests/data_sources/sun/test_sun_data_source.py
index 36e02842..ecadaec6 100644
--- a/tests/data_sources/sun/test_sun_data_source.py
+++ b/tests/data_sources/sun/test_sun_data_source.py
@@ -1,6 +1,7 @@
 """ Test for Sun data source """
 import pandas as pd
 
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.sun.sun_data_source import SunDataSource
 
 
@@ -20,7 +21,7 @@ def test_get_example(test_data_folder):  # noqa 103
     start_dt = pd.Timestamp("2020-04-01 12:00:00.000")
 
     example = sun_data_source.get_example(
-        t0_datetime_utc=start_dt, x_center_osgb=x, y_center_osgb=y
+        SpaceTimeLocation(t0_datetime_utc=start_dt, x_center_osgb=x, y_center_osgb=y)
     )
 
     assert len(example.elevation) == 19
@@ -37,7 +38,7 @@ def test_get_example_different_year(test_data_folder):  # noqa 103
     start_dt = pd.Timestamp("2021-04-01 12:00:00.000")
 
     example = sun_data_source.get_example(
-        t0_datetime_utc=start_dt, x_center_osgb=x, y_center_osgb=y
+        location=SpaceTimeLocation(t0_datetime_utc=start_dt, x_center_osgb=x, y_center_osgb=y)
     )
 
     assert len(example.elevation) == 19
diff --git a/tests/data_sources/test_nwp_data_source.py b/tests/data_sources/test_nwp_data_source.py
index f3f143fe..bb07f43c 100644
--- a/tests/data_sources/test_nwp_data_source.py
+++ b/tests/data_sources/test_nwp_data_source.py
@@ -4,6 +4,7 @@
 import pandas as pd
 
 import nowcasting_dataset
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 from nowcasting_dataset.data_sources.nwp.nwp_data_source import NWPDataSource
 
 PATH = os.path.dirname(nowcasting_dataset.__file__)
@@ -45,7 +46,15 @@ def test_nwp_data_source_batch():  # noqa: D103
     x = nwp._data.x_osgb[0:4].values
     y = nwp._data.y_osgb[0:4].values
 
-    batch = nwp.get_batch(t0_datetimes_utc=t0_datetimes, x_centers_osgb=x, y_centers_osgb=y)
+    locations = []
+    for i in range(0, 4):
+        locations.append(
+            SpaceTimeLocation(
+                t0_datetime_utc=t0_datetimes[i], x_center_osgb=x[i], y_center_osgb=y[i]
+            )
+        )
+
+    batch = nwp.get_batch(locations)
 
     # batch size 4
     # time series, 1 int he past, 1 now, 1 in the future
@@ -68,7 +77,12 @@ def test_nwp_data_source_batch_not_on_hour():  # noqa: D103
     x = nwp._data.x_osgb[0:1].values
     y = nwp._data.y_osgb[0:1].values
 
-    batch = nwp.get_batch(t0_datetimes_utc=t0_datetimes, x_centers_osgb=x, y_centers_osgb=y)
+    locations = []
+    locations.append(
+        SpaceTimeLocation(t0_datetime_utc=t0_datetimes[0], x_center_osgb=x[0], y_center_osgb=y[0])
+    )
+
+    batch = nwp.get_batch(locations)
 
     # batch size 1
     # time series, 1 int he past, 1 now, 1 in the future
diff --git a/tests/data_sources/test_pv_data_source.py b/tests/data_sources/test_pv_data_source.py
index 66343cc9..34c6d77a 100644
--- a/tests/data_sources/test_pv_data_source.py
+++ b/tests/data_sources/test_pv_data_source.py
@@ -55,13 +55,12 @@ def test_get_example_and_batch():  # noqa: D103
         load_from_gcs=False,
     )
 
-    x_locations, y_locations = pv_data_source.get_locations(pv_data_source.pv_power.index)
+    locations = pv_data_source.get_locations(pv_data_source.pv_power.index)
 
-    _ = pv_data_source.get_example(pv_data_source.pv_power.index[0], x_locations[0], y_locations[0])
+    _ = pv_data_source.get_example(location=locations[6])
 
-    batch = pv_data_source.get_batch(
-        pv_data_source.pv_power.index[6:16], x_locations[0:10], y_locations[0:10]
-    )
+    # start at 6, to avoid some nans
+    batch = pv_data_source.get_batch(locations=locations[6:16])
     assert batch.power_mw.shape == (10, 19, DEFAULT_N_PV_SYSTEMS_PER_EXAMPLE)
 
 
diff --git a/tests/data_sources/test_topographic_data_source.py b/tests/data_sources/test_topographic_data_source.py
index d0e9406d..f2589600 100644
--- a/tests/data_sources/test_topographic_data_source.py
+++ b/tests/data_sources/test_topographic_data_source.py
@@ -4,6 +4,7 @@
 import pytest
 
 from nowcasting_dataset.data_sources import TopographicDataSource
+from nowcasting_dataset.data_sources.metadata.metadata_model import SpaceTimeLocation
 
 
 @pytest.mark.parametrize(
@@ -31,7 +32,9 @@ def test_get_example_2km(x, y, left, right, top, bottom):
         history_minutes=10,
     )
     t0_dt = pd.Timestamp("2019-01-01T13:00")
-    topo_data = topo_source.get_example(t0_datetime_utc=t0_dt, x_center_osgb=x, y_center_osgb=y)
+    topo_data = topo_source.get_example(
+        SpaceTimeLocation(t0_datetime_utc=t0_dt, x_center_osgb=x, y_center_osgb=y)
+    )
     assert topo_data.data.shape == (128, 128)
     assert len(topo_data.x_osgb) == 128
     assert len(topo_data.y_osgb) == 128
@@ -59,6 +62,9 @@ def test_get_example_2km(x, y, left, right, top, bottom):
 )
 def test_get_batch_2km(x, y, left, right, top, bottom):
     """Test get batches"""
+
+    batch_size = 4
+
     size = 2000  # meters
     topo_source = TopographicDataSource(
         filename="tests/data/europe_dem_2km_osgb.tif",
@@ -67,12 +73,19 @@ def test_get_batch_2km(x, y, left, right, top, bottom):
         forecast_minutes=300,
         history_minutes=10,
     )
-    x = np.array([x] * 32)
-    y = np.array([y] * 32)
-    t0_datetimes = pd.date_range("2021-01-01", freq="5T", periods=32) + pd.Timedelta("30T")
-    topo_data = topo_source.get_batch(
-        t0_datetimes_utc=t0_datetimes, x_centers_osgb=x, y_centers_osgb=y
-    )
+    x = np.array([x] * batch_size)
+    y = np.array([y] * batch_size)
+    t0_datetimes = pd.date_range("2021-01-01", freq="5T", periods=batch_size) + pd.Timedelta("30T")
+
+    locations = []
+    for i in range(batch_size):
+        locations.append(
+            SpaceTimeLocation(
+                t0_datetime_utc=t0_datetimes[i], x_center_osgb=x[i], y_center_osgb=y[i]
+            )
+        )
+
+    topo_data = topo_source.get_batch(locations=locations)
     assert "x_index_index" not in topo_data.dims
 
 
diff --git a/tests/dataset/test_batch.py b/tests/dataset/test_batch.py
index a61ddd92..dccf8653 100644
--- a/tests/dataset/test_batch.py
+++ b/tests/dataset/test_batch.py
@@ -23,7 +23,7 @@ def test_model(configuration):  # noqa: D103
 def test_model_align_in_time(configuration):  # noqa: D103
     batch = Batch.fake(configuration=configuration, temporally_align_examples=True)
 
-    assert batch.metadata.t0_datetime_utc[0] == batch.metadata.t0_datetime_utc[1]
+    assert batch.metadata.t0_datetimes_utc[0] == batch.metadata.t0_datetimes_utc[1]
 
 
 def test_model_nwp_channels(configuration):  # noqa: D103
diff --git a/tests/manager/test_manager.py b/tests/manager/test_manager.py
index a57e95af..c84a3e0b 100644
--- a/tests/manager/test_manager.py
+++ b/tests/manager/test_manager.py
@@ -39,10 +39,9 @@ def test_sample_spatial_and_temporal_locations_for_examples(gsp, sun):  # noqa:
         t0_datetimes=t0_datetimes, n_examples=10
     )
 
-    assert locations.columns.to_list() == ["t0_datetime_UTC", "x_center_OSGB", "y_center_OSGB"]
     assert len(locations) == 10
-    assert (t0_datetimes[0] <= locations["t0_datetime_UTC"]).all()
-    assert (t0_datetimes[-1] >= locations["t0_datetime_UTC"]).all()
+    # assert (t0_datetimes[0] <= locations["t0_datetime_UTC"]).all()
+    # assert (t0_datetimes[-1] >= locations["t0_datetime_UTC"]).all()
 
 
 def test_initialize_data_source_with_loggers(test_configuration_filename):
diff --git a/tests/manager/test_manager_live.py b/tests/manager/test_manager_live.py
index d5ff4138..4cae22ff 100644
--- a/tests/manager/test_manager_live.py
+++ b/tests/manager/test_manager_live.py
@@ -25,7 +25,6 @@ def test_sample_spatial_and_temporal_locations_for_examples(
         t0_datetime=datetime(2020, 4, 1, 12)
     )
 
-    assert locations.columns.to_list() == ["t0_datetime_UTC", "x_center_OSGB", "y_center_OSGB"]
     assert len(locations) == 20