diff --git a/client/package.json b/client/package.json
index bc5e9d60..c478c896 100644
--- a/client/package.json
+++ b/client/package.json
@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "koji",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "description": "Tool to make RDM routes",
   "main": "server/dist/index.js",
   "author": "TurtIeSocks <58572875+TurtIeSocks@users.noreply.github.com>",
diff --git a/client/src/App.tsx b/client/src/App.tsx
index 973904c0..06a029e7 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -31,6 +31,11 @@ const router = createBrowserRouter([
     element: <Map />,
     errorElement: <ErrorPage error="500" />,
   },
+  {
+    path: '/map/:lat/:lon/:zoom?',
+    element: <Map />,
+    errorElement: <ErrorPage error="500" />,
+  },
   {
     path: '/admin/*',
     element: <AdminPanel />,
diff --git a/client/src/components/drawer/Layers.tsx b/client/src/components/drawer/Layers.tsx
index 5fdb1116..bedbb9c0 100644
--- a/client/src/components/drawer/Layers.tsx
+++ b/client/src/components/drawer/Layers.tsx
@@ -35,6 +35,7 @@ export default function Layers() {
       <DateTime field="last_seen" />
       <Divider sx={{ my: 2 }} />
       <ListSubheader disableGutters>S2 Cells</ListSubheader>
+      <Toggle field="fillCoveredCells" />
       <ListItem>
         <Select
           fullWidth
diff --git a/client/src/hooks/usePersist.ts b/client/src/hooks/usePersist.ts
index d0e40a5e..54236280 100644
--- a/client/src/hooks/usePersist.ts
+++ b/client/src/hooks/usePersist.ts
@@ -51,6 +51,7 @@ export interface UsePersist {
     route: [number, number][][]
   }
   s2cells: number[]
+  fillCoveredCells: boolean
   save_to_db: boolean
   save_to_scanner: boolean
   skipRendering: boolean
@@ -91,6 +92,7 @@ export const usePersist = create(
       data: 'bound',
       sort_by: 'GeoHash',
       s2cells: [],
+      fillCoveredCells: false,
       radius: 70,
       route_split_level: 1,
       routing_chunk_size: 0,
diff --git a/client/src/hooks/useShapes.ts b/client/src/hooks/useShapes.ts
index 495081da..613f8b60 100644
--- a/client/src/hooks/useShapes.ts
+++ b/client/src/hooks/useShapes.ts
@@ -27,6 +27,7 @@ export interface UseShapes {
   test: boolean
   activeRoute: string
   newRouteCount: number
+  s2cellCoverage: Record<string, string>
   kojiRefCache: Record<string, DbOption>
   firstPoint: keyof UseShapes['Point'] | null
   lastPoint: keyof UseShapes['Point'] | null
@@ -81,6 +82,7 @@ export interface UseShapes {
 export const useShapes = create<UseShapes>((set, get) => ({
   activeRoute: 'new_route_0',
   kojiRefCache: {},
+  s2cellCoverage: {},
   newRouteCount: 0,
   test: false,
   firstPoint: null,
diff --git a/client/src/hooks/useSyncGeojson.ts b/client/src/hooks/useSyncGeojson.ts
index faf0df9e..b9e23868 100644
--- a/client/src/hooks/useSyncGeojson.ts
+++ b/client/src/hooks/useSyncGeojson.ts
@@ -2,7 +2,8 @@
 import useDeepCompareEffect from 'use-deep-compare-effect'
 
 import { FeatureCollection } from '@assets/types'
-import { useShapes } from '@hooks/useShapes'
+import { UseShapes, useShapes } from '@hooks/useShapes'
+import { s2Coverage } from '@services/fetches'
 
 import { useStatic } from './useStatic'
 import { useDbCache } from './useDbCache'
@@ -16,6 +17,7 @@ export default function useSyncGeojson() {
   const multiPolygons = useShapes((s) => s.MultiPolygon)
 
   const geojson = useStatic((s) => s.geojson)
+
   const setStatic = useStatic((s) => s.setStatic)
 
   if (process.env.NODE_ENV === 'development') {
@@ -28,6 +30,7 @@ export default function useSyncGeojson() {
       features: [],
     }
     Object.values(points).forEach((point) => newGeojson.features.push(point))
+
     Object.values(multiPoints).forEach((multiPoint) =>
       newGeojson.features.push(multiPoint),
     )
@@ -43,6 +46,21 @@ export default function useSyncGeojson() {
     Object.values(multiPolygons).forEach((multiPolygon) =>
       newGeojson.features.push(multiPolygon),
     )
+    Promise.all(
+      Object.values(points).map((point) =>
+        s2Coverage(
+          point.id,
+          point.geometry.coordinates[1],
+          point.geometry.coordinates[0],
+        ),
+      ),
+    ).then((results) => {
+      const s2cellCoverage: UseShapes['s2cellCoverage'] = {}
+      results.forEach((result) => {
+        Object.assign(s2cellCoverage, result)
+      })
+      useShapes.setState({ s2cellCoverage })
+    })
     setStatic('geojson', newGeojson)
   }, [
     points,
diff --git a/client/src/pages/map/index.tsx b/client/src/pages/map/index.tsx
index 23434c26..d38adb0a 100644
--- a/client/src/pages/map/index.tsx
+++ b/client/src/pages/map/index.tsx
@@ -1,6 +1,7 @@
 import React from 'react'
 import { Box } from '@mui/material'
 import { Pane } from 'react-leaflet'
+import { useParams } from 'react-router'
 
 import { usePersist } from '@hooks/usePersist'
 
@@ -28,6 +29,7 @@ import {
 import { S2Cells } from './markers/S2'
 
 export default function MapWrapper() {
+  const params = useParams()
   const drawer = usePersist((s) => s.drawer)
   const menuItem = usePersist((s) => s.menuItem)
   const drawerWidth = menuItem === 'Geojson' ? 515 : 345
@@ -44,6 +46,10 @@ export default function MapWrapper() {
       </ErrorBoundary>
       <Main open={drawer} drawerWidth={drawerWidth}>
         <Map
+          forcedLocation={
+            params.lat && params.lon ? [+params.lat, +params.lon] : undefined
+          }
+          forcedZoom={params.zoom ? +params.zoom : undefined}
           style={{
             position: 'absolute',
             maxWidth: '100% !important',
@@ -55,10 +61,11 @@ export default function MapWrapper() {
             right: 0,
           }}
         >
-          <Pane name="circles" style={{ zIndex: 503 }} />
-          <Pane name="lines" style={{ zIndex: 502 }} />
-          <Pane name="arrows" style={{ zIndex: 501 }} />
-          <Pane name="polygons" style={{ zIndex: 500 }} />
+          <Pane name="circles" style={{ zIndex: 504 }} />
+          <Pane name="lines" style={{ zIndex: 503 }} />
+          <Pane name="arrows" style={{ zIndex: 502 }} />
+          <Pane name="polygons" style={{ zIndex: 501 }} />
+          <Pane name="s2" style={{ zIndex: 500 }} />
           <Markers category="pokestop" />
           <Markers category="spawnpoint" />
           <Markers category="gym" />
diff --git a/client/src/pages/map/markers/Point.tsx b/client/src/pages/map/markers/Point.tsx
index cb4892cb..67a5d567 100644
--- a/client/src/pages/map/markers/Point.tsx
+++ b/client/src/pages/map/markers/Point.tsx
@@ -8,6 +8,7 @@ import type { Feature, DbOption, KojiKey } from '@assets/types'
 import { useShapes } from '@hooks/useShapes'
 import { useStatic } from '@hooks/useStatic'
 import { usePersist } from '@hooks/usePersist'
+import { s2Coverage } from '@services/fetches'
 
 import BasePopup from '../popups/Styled'
 import { MemoPointPopup } from '../popups/Point'
@@ -41,14 +42,26 @@ export function KojiPoint({
           circle.on('pm:remove', function remove() {
             useShapes.getState().setters.remove(type, id)
           })
+          circle.removeEventListener('pm:drag')
+          circle.on('pm:drag', async function drag({ layer }) {
+            if (layer instanceof L.Circle) {
+              const latlng = layer.getLatLng()
+              useShapes.setState({
+                s2cellCoverage: await s2Coverage(id, latlng.lat, latlng.lng),
+              })
+            }
+          })
           circle.removeEventListener('pm:dragend')
-          circle.on('pm:dragend', function dragend({ layer }) {
+          circle.on('pm:dragend', async function dragend({ layer }) {
             if (layer instanceof L.Circle) {
               const { lat: newLat, lng: newLon } = circle.getLatLng()
               useShapes.getState().setters.update(type, id, {
                 ...useShapes.getState().Point[id],
                 geometry: { type: 'Point', coordinates: [newLon, newLat] },
               })
+              useShapes.setState({
+                s2cellCoverage: await s2Coverage(id, newLat, newLon),
+              })
             }
           })
           if (usePersist.getState().setActiveMode === 'hover') {
diff --git a/client/src/pages/map/markers/S2.tsx b/client/src/pages/map/markers/S2.tsx
index 7042272a..33ea89bc 100644
--- a/client/src/pages/map/markers/S2.tsx
+++ b/client/src/pages/map/markers/S2.tsx
@@ -1,29 +1,42 @@
 import * as React from 'react'
-import { Polyline, useMap } from 'react-leaflet'
+import { Polygon, Tooltip, useMap } from 'react-leaflet'
 import { KojiResponse } from '@assets/types'
 import { fetchWrapper } from '@services/fetches'
 import { getMapBounds } from '@services/utils'
 import { usePersist } from '@hooks/usePersist'
+import { useShapes } from '@hooks/useShapes'
+import { useStatic } from '@hooks/useStatic'
 
 interface S2Response {
   id: string
   coords: [number, number][]
 }
 
-function BaseCell({ id, coords }: S2Response) {
+function BaseCell({ id, coords, covered }: S2Response & { covered: boolean }) {
   return (
-    <Polyline
-      key={id}
-      positions={[...coords, coords[0]]}
-      color="black"
+    <Polygon
+      key={`${id}${covered}`}
+      pmIgnore
+      snapIgnore
+      positions={coords}
+      color={covered ? 'red' : 'black'}
+      fillOpacity={covered ? 0.2 : 0}
       weight={0.5}
-    />
+      pane="s2"
+    >
+      {process.env.NODE_ENV === 'development' && (
+        <Tooltip direction="center">{id}</Tooltip>
+      )}
+    </Polygon>
   )
 }
 
-const MemoBaseCell = React.memo(BaseCell, (prev, next) => prev.id === next.id)
+const MemoBaseCell = React.memo(
+  BaseCell,
+  (prev, next) => prev.id === next.id && prev.covered === next.covered,
+)
 
-function S2Cell({
+function S2Level({
   level,
   location,
 }: {
@@ -32,6 +45,7 @@ function S2Cell({
 }) {
   const map = useMap()
   const [data, setData] = React.useState<S2Response[]>([])
+  const covered = useShapes((s) => s.s2cellCoverage)
 
   React.useEffect(() => {
     const signal = new AbortController()
@@ -44,6 +58,17 @@ function S2Cell({
       signal: signal.signal,
     }).then((res) => {
       if (res) {
+        if (res.data.length === 10_000) {
+          useStatic.setState({
+            networkStatus: {
+              message: `Loaded the maximum of ${Number(
+                10_000,
+              ).toLocaleString()} Level ${level} S2 cells`,
+              severity: 'warning',
+              status: 200,
+            },
+          })
+        }
         setData(res.data)
       }
     })
@@ -53,14 +78,14 @@ function S2Cell({
   return (
     <>
       {data.map((cell) => (
-        <MemoBaseCell key={cell.id} {...cell} />
+        <MemoBaseCell key={cell.id} {...cell} covered={!!covered[cell.id]} />
       ))}
     </>
   )
 }
 
 const MemoS2Cell = React.memo(
-  S2Cell,
+  S2Level,
   (prev, next) =>
     prev.level === next.level &&
     prev.location.every((v, i) => v === next.location[i]),
diff --git a/client/src/services/fetches.ts b/client/src/services/fetches.ts
index 097e1751..e18b73cd 100644
--- a/client/src/services/fetches.ts
+++ b/client/src/services/fetches.ts
@@ -11,7 +11,7 @@ import type {
 } from '@assets/types'
 import { UsePersist, usePersist } from '@hooks/usePersist'
 import { useStatic } from '@hooks/useStatic'
-import { useShapes } from '@hooks/useShapes'
+import { UseShapes, useShapes } from '@hooks/useShapes'
 import { UseDbCache, useDbCache } from '@hooks/useDbCache'
 
 import { fromSnakeCase, getRouteType } from './utils'
@@ -416,3 +416,33 @@ export async function save(
     return null
   }
 }
+
+export async function s2Coverage(id: Feature['id'], lat: number, lon: number) {
+  const { s2cells, radius, fillCoveredCells } = usePersist.getState()
+  if (fillCoveredCells) {
+    const s2cellCoverage: UseShapes['s2cellCoverage'] = Object.fromEntries(
+      Object.entries(useShapes.getState().s2cellCoverage).filter(
+        ([, v]) => v !== id.toString(),
+      ),
+    )
+    await Promise.allSettled(
+      s2cells.map(async (level) =>
+        fetchWrapper<KojiResponse<string[]>>('/api/v1/s2/circle-coverage', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ lat, lon, radius, level }),
+        }).then((res) => {
+          if (res) {
+            res.data.forEach((cell) => {
+              if (!s2cellCoverage[cell]) s2cellCoverage[cell] = id.toString()
+            })
+          }
+        }),
+      ),
+    )
+    return s2cellCoverage
+  }
+  return {}
+}
diff --git a/server/Cargo.lock b/server/Cargo.lock
index cf21cd8b..52cd6d93 100644
--- a/server/Cargo.lock
+++ b/server/Cargo.lock
@@ -305,7 +305,7 @@ dependencies = [
 
 [[package]]
 name = "algorithms"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "geo",
  "geohash",
@@ -358,7 +358,7 @@ checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"
 
 [[package]]
 name = "api"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "actix-files",
  "actix-session",
@@ -2944,9 +2944,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.89"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020ff22c755c2ed3f8cf162dbb41a7268d934702f3ed3631656ea597e08fc3db"
+checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
 dependencies = [
  "itoa",
  "ryu",
diff --git a/server/algorithms/Cargo.toml b/server/algorithms/Cargo.toml
index c541f75a..5b06e237 100644
--- a/server/algorithms/Cargo.toml
+++ b/server/algorithms/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "algorithms"
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 publish = false
 
@@ -19,5 +19,6 @@ rand = "0.8.5"
 rstar = "0.10.0"
 s2 = "0.0.12"
 serde = { version = "1.0.136", features = ["derive"] }
+# serde_json = "1.0.94"
 shuffle = "0.1.7"
 # vrp-pragmatic = "1.18.3"
diff --git a/server/algorithms/src/s2.rs b/server/algorithms/src/s2.rs
index 4604e7f5..945886e0 100644
--- a/server/algorithms/src/s2.rs
+++ b/server/algorithms/src/s2.rs
@@ -1,3 +1,9 @@
+use std::{
+    collections::HashSet,
+    sync::{Arc, Mutex},
+};
+
+use geo::{HaversineDestination, Intersects};
 use s2::{cell::Cell, cellid::CellID, rect::Rect, region::RegionCoverer};
 use serde::Serialize;
 
@@ -23,13 +29,24 @@ pub fn get_cells(
     };
     let cells = cov.covering(&region);
 
-    cells.0.iter().map(get_polygon).collect()
+    cells
+        .0
+        .iter()
+        .enumerate()
+        .map_while(|(i, cell)| {
+            if i < 10_000 {
+                Some(get_polygon(cell))
+            } else {
+                None
+            }
+        })
+        .collect()
 }
 
 fn get_polygon(id: &CellID) -> S2Response {
     let cell = Cell::from(id);
     S2Response {
-        id: id.to_string(),
+        id: id.0.to_string(),
         coords: [
             [
                 cell.vertex(0).latitude().deg(),
@@ -50,3 +67,77 @@ fn get_polygon(id: &CellID) -> S2Response {
         ],
     }
 }
+
+pub fn circle_coverage(lat: f64, lon: f64, radius: f64, level: u8) -> Arc<Mutex<HashSet<String>>> {
+    let mut covered = Arc::new(Mutex::new(HashSet::new()));
+    let point = geo::Point::new(lon, lat);
+    let circle = geo::Polygon::<f64>::new(
+        geo::LineString::from(
+            (0..60)
+                .map(|i| point.haversine_destination((i * 6) as f64, radius))
+                .collect::<Vec<geo::Point>>(),
+        ),
+        vec![],
+    );
+    check_neighbors(lat, lon, level, &circle, &mut covered);
+
+    covered
+}
+
+fn check_neighbors(
+    lat: f64,
+    lon: f64,
+    level: u8,
+    circle: &geo::Polygon,
+    covered: &mut Arc<Mutex<HashSet<String>>>,
+) {
+    let center = s2::latlng::LatLng::from_degrees(lat, lon);
+    let center_cell = CellID::from(center).parent(level as u64);
+    covered.lock().unwrap().insert(center_cell.0.to_string());
+    let mut next_neighbors: Vec<(f64, f64)> = Vec::new();
+    let current_neighbors = center_cell.edge_neighbors();
+
+    current_neighbors.iter().for_each(|neighbor| {
+        let id = neighbor.0.to_string();
+        if covered.lock().unwrap().contains(&id) {
+            return;
+        }
+        let cell = Cell::from(neighbor);
+        let polygon = geo::Polygon::<f64>::new(
+            geo::LineString::from(
+                (0..4)
+                    .map(|i| {
+                        geo::Point::new(
+                            cell.vertex(i).longitude().deg(),
+                            cell.vertex(i).latitude().deg(),
+                        )
+                    })
+                    .collect::<Vec<geo::Point>>(),
+            ),
+            vec![],
+        );
+        if polygon.intersects(circle) {
+            covered.lock().unwrap().insert(id);
+            next_neighbors.push((
+                cell.center().latitude().deg(),
+                cell.center().longitude().deg(),
+            ));
+        }
+    });
+
+    if !next_neighbors.is_empty() {
+        let mut threads = vec![];
+
+        for neighbor in next_neighbors {
+            let mut covered = covered.clone();
+            let circle = circle.clone();
+            threads.push(std::thread::spawn(move || {
+                check_neighbors(neighbor.0, neighbor.1, level, &circle, &mut covered)
+            }));
+        }
+
+        for thread in threads {
+            thread.join().unwrap();
+        }
+    }
+}
diff --git a/server/api/Cargo.toml b/server/api/Cargo.toml
index 57d50d3c..10089ede 100644
--- a/server/api/Cargo.toml
+++ b/server/api/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "api"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2021"
 publish = false
 
diff --git a/server/api/src/lib.rs b/server/api/src/lib.rs
index 30498c54..74ed00e7 100644
--- a/server/api/src/lib.rs
+++ b/server/api/src/lib.rs
@@ -154,7 +154,11 @@ pub async fn start() -> io::Result<()> {
                                 .service(public::v1::route::specific_return_type)
                                 .service(public::v1::route::specific_project),
                         )
-                        .service(web::scope("/s2").service(public::v1::s2::s2_cells)),
+                        .service(
+                            web::scope("/s2")
+                                .service(public::v1::s2::circle_intersection)
+                                .service(public::v1::s2::s2_cells),
+                        ),
                 ),
             )
             .service(
diff --git a/server/api/src/public/v1/s2.rs b/server/api/src/public/v1/s2.rs
index fc523738..630ba12b 100644
--- a/server/api/src/public/v1/s2.rs
+++ b/server/api/src/public/v1/s2.rs
@@ -1,19 +1,47 @@
 use super::*;
 
-use algorithms::s2::get_cells;
+use algorithms::s2::{circle_coverage, get_cells};
 
 use model::api::args::{BoundsArg, Response};
+use serde::Deserialize;
 use serde_json::json;
 
+#[derive(Debug, Clone, Deserialize)]
+struct CircleArgs {
+    lat: f64,
+    lon: f64,
+    radius: f64,
+    level: u8,
+}
+
+#[post("/circle-coverage")]
+async fn circle_intersection(payload: web::Json<CircleArgs>) -> Result<HttpResponse, Error> {
+    let CircleArgs {
+        lat,
+        lon,
+        radius,
+        level,
+    } = payload.into_inner();
+
+    let result = circle_coverage(lat, lon, radius, level);
+    Ok(HttpResponse::Ok().json(Response {
+        data: Some(json!(result)),
+        message: "Success".to_string(),
+        status: "ok".to_string(),
+        stats: None,
+        status_code: 200,
+    }))
+}
+
 #[post("/{cell_level}")]
 async fn s2_cells(
     payload: web::Json<BoundsArg>,
     url: actix_web::web::Path<u8>,
 ) -> Result<HttpResponse, Error> {
     let bounds = payload.into_inner();
-    let cell = url.into_inner();
+    let cell_level = url.into_inner();
     let feature = get_cells(
-        cell,
+        cell_level,
         bounds.min_lat,
         bounds.min_lon,
         bounds.max_lat,