diff --git a/src/api/v1/servers/mod.rs b/src/api/v1/servers/mod.rs
index 7c74ff0..8e536be 100644
--- a/src/api/v1/servers/mod.rs
+++ b/src/api/v1/servers/mod.rs
@@ -1,9 +1,9 @@
-use actix_web::{get, post, web, Error, HttpRequest, HttpResponse, Scope};
+use actix_web::{Error, HttpRequest, HttpResponse, Scope, post, web};
 use serde::Deserialize;
 
 mod uuid;
 
-use crate::{api::v1::auth::check_access_token, structs::{Guild, StartAmountQuery}, utils::get_auth_header, Data};
+use crate::{Data, api::v1::auth::check_access_token, structs::Guild, utils::get_auth_header};
 
 #[derive(Deserialize)]
 struct GuildInfo {
@@ -12,14 +12,11 @@ struct GuildInfo {
 }
 
 pub fn web() -> Scope {
-    web::scope("/servers")
-        .service(create)
-        .service(get)
-        .service(uuid::web())
+    web::scope("/servers").service(res).service(uuid::web())
 }
 
 #[post("")]
-pub async fn create(
+pub async fn res(
     req: HttpRequest,
     guild_info: web::Json<GuildInfo>,
     data: web::Data<Data>,
@@ -54,37 +51,3 @@ pub async fn create(
 
     Ok(HttpResponse::Ok().json(guild.unwrap()))
 }
-
-#[get("")]
-pub async fn get(
-    req: HttpRequest,
-    request_query: web::Query<StartAmountQuery>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers);
-
-    let start = request_query.start.unwrap_or(0);
-
-    let amount = request_query.amount.unwrap_or(10);
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
-
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    let guilds = Guild::fetch_amount(&data.pool, start, amount).await;
-
-    if let Err(error) = guilds {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guilds.unwrap()))
-}
-
diff --git a/src/api/v1/users/mod.rs b/src/api/v1/users/mod.rs
index 96e1b4b..de9aec0 100644
--- a/src/api/v1/users/mod.rs
+++ b/src/api/v1/users/mod.rs
@@ -1,9 +1,16 @@
-use crate::{api::v1::auth::check_access_token, structs::{StartAmountQuery, User}, utils::get_auth_header, Data};
+use crate::{api::v1::auth::check_access_token, structs::User, utils::get_auth_header, Data};
 use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use serde::Deserialize;
 
 mod me;
 mod uuid;
 
+#[derive(Deserialize)]
+struct RequestQuery {
+    start: Option<i32>,
+    amount: Option<i32>,
+}
+
 pub fn web() -> Scope {
     web::scope("/users")
         .service(res)
@@ -14,7 +21,7 @@ pub fn web() -> Scope {
 #[get("")]
 pub async fn res(
     req: HttpRequest,
-    request_query: web::Query<StartAmountQuery>,
+    request_query: web::Query<RequestQuery>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
diff --git a/src/structs.rs b/src/structs.rs
index 3c7a656..a6e1587 100644
--- a/src/structs.rs
+++ b/src/structs.rs
@@ -331,57 +331,6 @@ impl Guild {
         })
     }
 
-    pub async fn fetch_amount(
-        pool: &Pool<Postgres>,
-        start: i32,
-        amount: i32,
-    ) -> Result<Vec<Self>, HttpResponse> {
-        // Fetch guild data from database
-        let rows = sqlx::query_as::<_, (String, String, String, Option<String>, Option<String>)>(
-            "SELECT CAST(uuid AS VARCHAR), CAST(owner_uuid AS VARCHAR), name, description, icon 
-            FROM guilds 
-            ORDER BY name 
-            LIMIT $1 OFFSET $2",
-        )
-        .bind(amount)
-        .bind(start)
-        .fetch_all(pool)
-        .await
-        .map_err(|error| {
-            error!("{}", error);
-            HttpResponse::InternalServerError().finish()
-        })?;
-
-        // Process each guild concurrently
-        let guild_futures = rows.into_iter().map(|(guild_uuid_raw, owner_uuid_raw, name, description, icon)| async move {
-            let uuid = Uuid::from_str(&guild_uuid_raw).map_err(|_| {
-                HttpResponse::BadRequest().body("Invalid guild UUID format")
-            })?;
-
-            let owner_uuid = Uuid::from_str(&owner_uuid_raw).map_err(|_| {
-                HttpResponse::BadRequest().body("Invalid owner UUID format")
-            })?;
-
-            let (member_count, roles) = tokio::try_join!(
-                Member::count(pool, uuid),
-                Role::fetch_all(pool, uuid)
-            )?;
-
-            Ok::<Guild, HttpResponse>(Self {
-                uuid,
-                name,
-                description,
-                icon,
-                owner_uuid,
-                roles,
-                member_count,
-            })
-        });
-
-        // Execute all futures concurrently and collect results
-        futures::future::try_join_all(guild_futures).await
-    }
-
     pub async fn new(
         pool: &Pool<Postgres>,
         name: String,
@@ -953,9 +902,3 @@ impl Me {
         Ok(me.unwrap().build())
     }
 }
-
-#[derive(Deserialize)]
-pub struct StartAmountQuery {
-    pub start: Option<i32>,
-    pub amount: Option<i32>,
-}