diff --git a/packages/api-v4/src/quotas/quotas.ts b/packages/api-v4/src/quotas/quotas.ts
index e32c94bd071..0849e7f6f3f 100644
--- a/packages/api-v4/src/quotas/quotas.ts
+++ b/packages/api-v4/src/quotas/quotas.ts
@@ -1,7 +1,7 @@
 import { BETA_API_ROOT } from '../constants';
 import Request, { setMethod, setParams, setURL, setXFilter } from '../request';
 
-import type { Quota, QuotaType, QuotaUsage } from './types';
+import type { Quota, QuotaServiceType, QuotaUsage } from './types';
 import type { Filter, ResourcePage as Page, Params } from 'src/types';
 
 /**
@@ -9,34 +9,40 @@ import type { Filter, ResourcePage as Page, Params } from 'src/types';
  *
  * Returns the details for a single quota within a particular service specified by `type`.
  *
- * @param type { QuotaType } retrieve a quota within this service type.
+ * @param quotaService { QuotaServiceType } retrieve a quota within this service type.
  * @param id { number } the quota ID to look up.
- * @param collection { string } quota collection name (quotas/global-quotas).
+ * @param apiCollection { string } quota collection name (quotas/global-quotas).
  */
-export const getQuota = (type: QuotaType, collection: string, id: number) =>
+export const getQuota = (
+  quotaService: QuotaServiceType,
+  apiCollection: string,
+  id: number,
+) =>
   Request<Quota>(
-    setURL(`${BETA_API_ROOT}/${type}/${collection}/${id}`),
+    setURL(`${BETA_API_ROOT}/${quotaService}/${apiCollection}/${id}`),
     setMethod('GET'),
   );
 
 /**
  * getQuotas
  *
- * Returns a paginated list of quotas for a particular service specified by `type`.
+ * Returns a paginated list of quotas for a particular service specified by `quotaService`.
  *
  * This request can be filtered on `quota_name`, `service_name` and `scope`.
  *
- * @param type { QuotaType } retrieve quotas within this service type.
- * @param collection { string } quota collection name (quotas/global-quotas).
+ * @param quotaService { QuotaServiceType } retrieve quotas within this service quotaService.
+ * @param apiCollection { string } quota API collection name (e.g. quotas, global-quotas, etc.).
+ * @param params { Params } query params to include in the request.
+ * @param filter { Filter } filters to include in the request.
  */
 export const getQuotas = (
-  type: QuotaType,
-  collection: string,
+  quotaService: QuotaServiceType,
+  apiCollection: string,
   params: Params = {},
   filter: Filter = {},
 ) =>
   Request<Page<Quota>>(
-    setURL(`${BETA_API_ROOT}/${type}/${collection}`),
+    setURL(`${BETA_API_ROOT}/${quotaService}/${apiCollection}`),
     setMethod('GET'),
     setXFilter(filter),
     setParams(params),
@@ -47,16 +53,16 @@ export const getQuotas = (
  *
  * Returns the usage for a single quota within a particular service specified by `type`.
  *
- * @param type { QuotaType } retrieve a quota within this service type.
- * @param collection { string } quota collection name (quotas/global-quotas).
+ * @param quotaService { QuotaServiceType } retrieve a quota within this service type.
+ * @param apiCollection { string } quota collection name (quotas/global-quotas).
  * @param id { string } the quota ID to look up.
  */
 export const getQuotaUsage = (
-  type: QuotaType,
-  collection: string,
+  quotaService: QuotaServiceType,
+  apiCollection: string,
   id: string,
 ) =>
   Request<QuotaUsage>(
-    setURL(`${BETA_API_ROOT}/${type}/${collection}/${id}/usage`),
+    setURL(`${BETA_API_ROOT}/${quotaService}/${apiCollection}/${id}/usage`),
     setMethod('GET'),
   );
diff --git a/packages/api-v4/src/quotas/types.ts b/packages/api-v4/src/quotas/types.ts
index c21a9beff78..33d5fd80711 100644
--- a/packages/api-v4/src/quotas/types.ts
+++ b/packages/api-v4/src/quotas/types.ts
@@ -1,40 +1,22 @@
 import type { ObjectStorageEndpointTypes } from 'src/object-storage';
 import type { Region } from 'src/regions';
 
-export enum QuotaResourceMetrics {
-  BUCKET = 'bucket',
-  BYTE = 'byte',
-  BYTE_PER_SECOND = 'byte_per_second',
-  CLUSTER = 'cluster',
-  CPU = 'CPU',
-  GPU = 'GPU',
-  OBJECT = 'object',
-  REQUEST = 'request',
-  VPU = 'VPU',
-}
+export type LinodeQuotaResourceMetric = 'CPU' | 'GPU' | 'VPU';
+export type LkeQuotaResourceMetric = 'cluster';
+export type ObjectStorageEndpointQuotaResourceMetric =
+  | 'bucket'
+  | 'byte'
+  | 'byte_per_second'
+  | 'object'
+  | 'request';
+export type ObjectStorageGlobalQuotaResourceMetric = 'key';
 
-/**
- * A Quota is a service used limit that is rated based on service metrics such
- * as vCPUs used, instances or storage size.
- */
-export interface Quota {
+interface QuotaCommon<T> {
   /**
    * Longer explanatory description for the quota.
    */
   description: string;
 
-  /**
-   * The OBJ endpoint type to which this limit applies.
-   *
-   * For OBJ limits only.
-   */
-  endpoint_type?: ObjectStorageEndpointTypes;
-
-  /**
-   * Sets usage column to be n/a when value is false.
-   */
-  has_usage?: boolean;
-
   /**
    * A unique identifier for the quota.
    */
@@ -52,31 +34,80 @@ export interface Quota {
   quota_name: string;
 
   /**
-   * Customer facing id describing the quota.
+   * The unit of measurement for this service limit.
    */
-  quota_type: string;
+  resource_metric: T;
+}
 
+interface QuotaCommonWithRegionApplied<T> extends QuotaCommon<T> {
   /**
    * The region slug to which this limit applies.
    *
    * OBJ limits are applied by endpoint, not region.
    * This below really just is a `string` type but being verbose helps with reading comprehension.
    */
-  region_applied?: 'global' | Region['id'];
+  region_applied: 'global' | Region['id'];
+}
 
+interface QuotaCommonWithUsage<T> extends QuotaCommon<T> {
   /**
-   * The unit of measurement for this service limit.
+   * Determines whether usage information is provided for this quota.
+   */
+  has_usage: boolean;
+}
+
+export type LinodeQuota =
+  QuotaCommonWithRegionApplied<LinodeQuotaResourceMetric>;
+
+export type LkeQuota = QuotaCommonWithRegionApplied<LkeQuotaResourceMetric>;
+
+export interface ObjectStorageGlobalQuota
+  extends QuotaCommon<ObjectStorageGlobalQuotaResourceMetric> {
+  /**
+   * Represents the quota type.
+   */
+  quota_type: 'keys';
+}
+
+export interface ObjectStorageEndpointQuota
+  extends QuotaCommonWithUsage<ObjectStorageEndpointQuotaResourceMetric> {
+  /**
+   * The OBJ endpoint type to which this limit applies.
+   *
+   */
+  endpoint_type: ObjectStorageEndpointTypes;
+
+  /**
+   * Represents the quota type.
    */
-  resource_metric: QuotaResourceMetrics;
+  quota_type:
+    | 'obj-buckets'
+    | 'obj-bytes'
+    | 'obj-objects'
+    | 'obj-per-ip-concurrent-requests'
+    | 'obj-per-ip-egress-throughput'
+    | 'obj-per-ip-ingress-throughput'
+    | 'obj-total-concurrent-requests'
+    | 'obj-total-egress-throughput'
+    | 'obj-total-ingress-throughput';
 
   /**
    * The S3 endpoint URL to which this limit applies.
    *
-   * For OBJ limits only.
    */
-  s3_endpoint?: string;
+  s3_endpoint: string;
 }
 
+/**
+ * A Quota is a service used limit that is rated based on service metrics such
+ * as vCPUs used, instances or storage size.
+ */
+export type Quota =
+  | LinodeQuota
+  | LkeQuota
+  | ObjectStorageEndpointQuota
+  | ObjectStorageGlobalQuota;
+
 /**
  * A usage limit for a given Quota based on service metrics such
  * as vCPUs, instances or storage size.
@@ -97,10 +128,8 @@ export interface QuotaUsage {
   usage: null | number;
 }
 
-export const quotaTypes = {
-  linode: 'Linodes',
-  lke: 'Kubernetes',
-  'object-storage': 'Object Storage',
-} as const;
-
-export type QuotaType = keyof typeof quotaTypes;
+/**
+ * Represents the type of service for a given quota, e.g. Linodes, Object Storage, etc.
+ * The type must match the service part of the quota endpoint paths.
+ */
+export type QuotaServiceType = 'linode' | 'lke' | 'object-storage';
diff --git a/packages/manager/cypress/e2e/core/account/quotas-storage.spec.ts b/packages/manager/cypress/e2e/core/account/quotas-storage.spec.ts
index 4962af2027d..3f8a7d5461a 100644
--- a/packages/manager/cypress/e2e/core/account/quotas-storage.spec.ts
+++ b/packages/manager/cypress/e2e/core/account/quotas-storage.spec.ts
@@ -1,4 +1,3 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import { regionFactory } from '@linode/utilities';
 import { profileFactory } from '@linode/utilities';
 import { mockAppendFeatureFlags } from 'support/intercepts/feature-flags';
@@ -20,10 +19,14 @@ import { randomDomainName, randomLabel } from 'support/util/random';
 
 import { supportTicketFactory } from 'src/factories';
 import { objectStorageEndpointsFactory } from 'src/factories';
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import {
+  objEndpointQuotaFactory,
+  quotaUsageFactory,
+} from 'src/factories/quotas';
+import { objectStorageQuotaService } from 'src/features/Account/Quotas/quotaServices';
 import { getQuotaIncreaseMessage } from 'src/features/Account/Quotas/utils';
 
-import type { Quota } from '@linode/api-v4';
+import type { ObjectStorageEndpointQuota, Quota } from '@linode/api-v4';
 
 const mockFeatureFlags = {
   limitsEvolution: {
@@ -33,7 +36,7 @@ const mockFeatureFlags = {
   objectStorageGlobalQuotas: false,
 };
 
-const placeholderText = 'Select an Object Storage S3 endpoint';
+const placeholderText = 'Select an Object Storage endpoint';
 
 const mockDomain = randomDomainName();
 
@@ -68,34 +71,34 @@ const mockSelectedEndpoint = mockEndpoints[1];
 const selectedDomain = mockSelectedEndpoint.s3_endpoint || '';
 
 const mockQuotas = [
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-bytes-${selectedDomain}`,
     quota_type: 'obj-bytes',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
     quota_limit: 10,
     quota_name: randomLabel(15),
-    resource_metric: QuotaResourceMetrics.BYTE,
+    resource_metric: 'byte',
     s3_endpoint: selectedDomain,
   }),
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-buckets-${selectedDomain}`,
     quota_type: 'obj-buckets',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
     quota_limit: 78,
     quota_name: randomLabel(15),
-    resource_metric: QuotaResourceMetrics.BUCKET,
+    resource_metric: 'bucket',
     s3_endpoint: selectedDomain,
   }),
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-objects-${selectedDomain}`,
     quota_type: 'obj-objects',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
     quota_limit: 400,
     quota_name: randomLabel(15),
-    resource_metric: QuotaResourceMetrics.OBJECT,
+    resource_metric: 'object',
     s3_endpoint: selectedDomain,
   }),
 ];
@@ -151,7 +154,7 @@ describe('Quota workflow tests', () => {
 
   describe('Quota storage table', () => {
     it('Quotas and quota usages display properly', () => {
-      cy.visitWithLogin('/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
 
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
 
@@ -175,7 +178,7 @@ describe('Quota workflow tests', () => {
 
       cy.wait(['@getQuotas', '@getQuotaUsages']);
 
-      cy.get('table[data-testid="table-endpoint-quotas"]')
+      cy.get('[data-testid="quotas-table-obj-endpoint"]')
         .find('tbody')
         .within(() => {
           cy.get('[data-testid="table-row-empty"]').should('not.exist');
@@ -223,34 +226,34 @@ describe('Quota workflow tests', () => {
       const updatedEndpoint = mockEndpoints[mockEndpoints.length - 1];
       const updatedDomain = updatedEndpoint.s3_endpoint || '';
       const updatedQuotas = [
-        quotaFactory.build({
+        objEndpointQuotaFactory.build({
           quota_id: `obj-bytes-${updatedDomain}`,
           quota_type: 'obj-bytes',
           description: randomLabel(50),
           endpoint_type: updatedEndpoint.endpoint_type,
           quota_limit: 20,
           quota_name: randomLabel(15),
-          resource_metric: QuotaResourceMetrics.BYTE,
+          resource_metric: 'byte',
           s3_endpoint: updatedDomain,
         }),
-        quotaFactory.build({
+        objEndpointQuotaFactory.build({
           quota_id: `obj-buckets-${updatedDomain}`,
           quota_type: 'obj-buckets',
           description: randomLabel(50),
           endpoint_type: updatedEndpoint.endpoint_type,
           quota_limit: 122,
           quota_name: randomLabel(15),
-          resource_metric: QuotaResourceMetrics.BUCKET,
+          resource_metric: 'bucket',
           s3_endpoint: updatedDomain,
         }),
-        quotaFactory.build({
+        objEndpointQuotaFactory.build({
           quota_id: `obj-objects-${updatedDomain}`,
           quota_type: 'obj-objects',
           description: randomLabel(50),
           endpoint_type: updatedEndpoint.endpoint_type,
           quota_limit: 450,
           quota_name: randomLabel(15),
-          resource_metric: QuotaResourceMetrics.OBJECT,
+          resource_metric: 'object',
           s3_endpoint: updatedDomain,
         }),
       ];
@@ -295,10 +298,7 @@ describe('Quota workflow tests', () => {
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
         .should('be.visible')
-        .clear();
-      ui.autocomplete
-        .findByLabel('Object Storage Endpoint')
-        .type(updatedDomain);
+        .click();
       ui.autocompletePopper
         .findByTitle(updatedDomain, { exact: false })
         .should('be.visible')
@@ -306,7 +306,7 @@ describe('Quota workflow tests', () => {
 
       cy.wait(['@getUpdatedQuotas', '@getUpdatedQuotaUsages']);
 
-      cy.get('table[data-testid="table-endpoint-quotas"]')
+      cy.get('[data-testid="quotas-table-obj-endpoint"]')
         .find('tbody')
         .within(() => {
           cy.get('[data-testid="table-row-empty"]').should('not.exist');
@@ -354,7 +354,7 @@ describe('Quota workflow tests', () => {
       const errorMsg = 'Request failed.';
       mockGetObjectStorageQuotaError(errorMsg).as('getQuotasError');
 
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
 
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
@@ -366,7 +366,7 @@ describe('Quota workflow tests', () => {
         .should('be.visible')
         .click();
       cy.wait('@getQuotasError');
-      cy.get('[data-testid="endpoint-quotas-table-container"]').within(() => {
+      cy.get('[data-testid="quotas-table-obj-endpoint"]').within(() => {
         cy.get('[data-qa-error-msg="true"]')
           .should('be.visible')
           .should('have.text', errorMsg);
@@ -403,7 +403,7 @@ describe('Quota workflow tests', () => {
         },
       ];
       mockQuotas.forEach((mockQuota: Quota, index: number) => {
-        cy.visitWithLogin('/account/quotas');
+        cy.visitWithLogin('/quotas?service=object-storage');
         cy.wait([
           '@getFeatureFlags',
           '@getProfile',
@@ -422,10 +422,9 @@ describe('Quota workflow tests', () => {
             profile: mockProfile,
             quantity: expectedResults[index].newQuotaLimit,
             quota: mockQuota,
-            selectedService: {
-              label: 'Object Storage',
-              value: 'object-storage',
-            },
+            service: objectStorageQuotaService(),
+            scope: 'obj-endpoint',
+            scopeValue: (mockQuota as ObjectStorageEndpointQuota).s3_endpoint,
           }).description,
         });
         cy.findByPlaceholderText(placeholderText)
@@ -524,7 +523,7 @@ describe('Quota workflow tests', () => {
     it('Quota error results in error message being displayed', () => {
       const errorMsg = 'Request failed.';
       mockGetObjectStorageQuotaError(errorMsg).as('getQuotasError');
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
 
       cy.wait('@getObjectStorageEndpoints');
 
@@ -538,7 +537,7 @@ describe('Quota workflow tests', () => {
         .click();
       cy.wait('@getQuotasError');
 
-      cy.get('[data-testid="endpoint-quotas-table-container"]').within(() => {
+      cy.get('[data-testid="quotas-table-obj-endpoint"]').within(() => {
         cy.get('[data-qa-error-msg="true"]')
           .should('be.visible')
           .should('have.text', errorMsg);
@@ -551,7 +550,7 @@ describe('Quota workflow tests', () => {
       mockApiInternalUser();
       const errorMessage = 'Ticket creation failed.';
       mockCreateSupportTicketError(errorMessage).as('createTicketError');
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
 
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
 
@@ -601,7 +600,7 @@ describe('Quota workflow tests', () => {
           requestForIncreaseDisabledForInternalAccountsOnly: false,
         },
       }).as('getFeatureFlags');
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
@@ -635,7 +634,7 @@ describe('Quota workflow tests', () => {
 
       mockApiInternalUser();
 
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
@@ -665,7 +664,7 @@ describe('Quota workflow tests', () => {
           requestForIncreaseDisabledForAll: true,
         },
       }).as('getFeatureFlags');
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
@@ -696,7 +695,7 @@ describe('Quota workflow tests', () => {
         },
       }).as('getFeatureFlags');
       mockApiInternalUser();
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
@@ -727,7 +726,7 @@ describe('Quota workflow tests', () => {
           requestForIncreaseDisabledForInternalAccountsOnly: true,
         },
       }).as('getFeatureFlags');
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
@@ -759,7 +758,7 @@ describe('Quota workflow tests', () => {
         },
       }).as('getFeatureFlags');
       mockApiInternalUser();
-      cy.visitWithLogin('/account/quotas');
+      cy.visitWithLogin('/quotas?service=object-storage');
       cy.wait(['@getFeatureFlags', '@getObjectStorageEndpoints']);
       ui.autocomplete
         .findByLabel('Object Storage Endpoint')
diff --git a/packages/manager/cypress/e2e/core/objectStorage/object-storage-summary-page.spec.ts b/packages/manager/cypress/e2e/core/objectStorage/object-storage-summary-page.spec.ts
index 49758107569..6f9e980b878 100644
--- a/packages/manager/cypress/e2e/core/objectStorage/object-storage-summary-page.spec.ts
+++ b/packages/manager/cypress/e2e/core/objectStorage/object-storage-summary-page.spec.ts
@@ -1,4 +1,3 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import { regionFactory } from '@linode/utilities';
 import { authenticate } from 'support/api/authentication';
 import { mockAppendFeatureFlags } from 'support/intercepts/feature-flags';
@@ -11,7 +10,10 @@ import { ui } from 'support/ui';
 import { randomDomainName, randomLabel } from 'support/util/random';
 
 import { objectStorageEndpointsFactory } from 'src/factories';
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import {
+  objEndpointQuotaFactory,
+  quotaUsageFactory,
+} from 'src/factories/quotas';
 
 const mockFeatureFlags = {
   objSummaryPage: true,
@@ -51,35 +53,36 @@ const mockEndpoints = [
 const mockSelectedEndpoint = mockEndpoints[1];
 const selectedDomain = mockSelectedEndpoint.s3_endpoint || '';
 
+// the order must match the display order in the UI
 const mockQuotas = [
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-bytes-${selectedDomain}`,
     quota_type: 'obj-bytes',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
     quota_limit: 10,
     quota_name: 'Total Capacity',
-    resource_metric: QuotaResourceMetrics.BYTE,
+    resource_metric: 'byte',
     s3_endpoint: selectedDomain,
   }),
-  quotaFactory.build({
-    quota_id: `obj-buckets-${selectedDomain}`,
-    quota_type: 'obj-buckets',
+  objEndpointQuotaFactory.build({
+    quota_id: `obj-objects-${selectedDomain}`,
+    quota_type: 'obj-objects',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
-    quota_limit: 78,
+    quota_limit: 400,
     quota_name: 'Number of Objects',
-    resource_metric: QuotaResourceMetrics.BUCKET,
+    resource_metric: 'object',
     s3_endpoint: selectedDomain,
   }),
-  quotaFactory.build({
-    quota_id: `obj-objects-${selectedDomain}`,
-    quota_type: 'obj-objects',
+  objEndpointQuotaFactory.build({
+    quota_id: `obj-buckets-${selectedDomain}`,
+    quota_type: 'obj-buckets',
     description: randomLabel(50),
     endpoint_type: mockSelectedEndpoint.endpoint_type,
-    quota_limit: 400,
+    quota_limit: 78,
     quota_name: 'Number of Buckets',
-    resource_metric: QuotaResourceMetrics.OBJECT,
+    resource_metric: 'bucket',
     s3_endpoint: selectedDomain,
   }),
 ];
@@ -108,30 +111,25 @@ describe('Object storage summary page test', () => {
       'getObjectStorageEndpoints'
     );
 
-    cy.wrap(selectedDomain).as('selectedDomain');
-    cy.wrap(mockEndpoints).as('mockEndpoints');
-    cy.wrap(mockQuotas).as('mockQuotas');
-    cy.wrap(mockQuotaUsages).as('mockQuotaUsages');
-
     mockGetObjectStorageQuotas(selectedDomain, mockQuotas).as('getQuotas');
 
     mockGetObjectStorageQuotaUsages(
       selectedDomain,
       'bytes',
       mockQuotaUsages[0]
-    );
+    ).as('getQuotaUsageBytes');
 
     mockGetObjectStorageQuotaUsages(
       selectedDomain,
-      'buckets',
+      'objects',
       mockQuotaUsages[1]
-    );
+    ).as('getQuotaUsageObjects');
 
     mockGetObjectStorageQuotaUsages(
       selectedDomain,
-      'objects',
+      'buckets',
       mockQuotaUsages[2]
-    ).as('getQuotaUsages');
+    ).as('getQuotaUsageBuckets');
   });
 
   it('should display table with user quotas', () => {
@@ -152,7 +150,12 @@ describe('Object storage summary page test', () => {
       .click();
     endpointSelect.click();
 
-    cy.wait(['@getQuotas', '@getQuotaUsages']);
+    cy.wait([
+      '@getQuotas',
+      '@getQuotaUsageBytes',
+      '@getQuotaUsageBuckets',
+      '@getQuotaUsageObjects',
+    ]);
 
     cy.findByTestId('table-endpoint-summary')
       .find('tbody')
diff --git a/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.test.tsx b/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.test.tsx
index 51c230bdc35..1eb39ebc1bc 100644
--- a/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.test.tsx
+++ b/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.test.tsx
@@ -1,4 +1,3 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import React from 'react';
 
 import { renderWithTheme } from 'src/utilities/testHelpers';
@@ -44,11 +43,7 @@ describe('QuotaUsageBanner', () => {
     'should display correct byte quota usage text for $usage bytes used out of $limit bytes',
     ({ usage, limit, expectedText }) => {
       const { getByText } = renderWithTheme(
-        <QuotaUsageBar
-          limit={limit}
-          resourceMetric={QuotaResourceMetrics.BYTE}
-          usage={usage}
-        />
+        <QuotaUsageBar limit={limit} resourceMetric="byte" usage={usage} />
       );
       const quotaUsageText = getByText(expectedText);
       expect(quotaUsageText).toBeVisible();
diff --git a/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.tsx b/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.tsx
index e5acc41f6cc..eede34e761a 100644
--- a/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.tsx
+++ b/packages/manager/src/components/QuotaUsageBar/QuotaUsageBar.tsx
@@ -4,11 +4,11 @@ import * as React from 'react';
 import { BarPercent } from 'src/components/BarPercent';
 import { convertResourceMetric } from 'src/features/Account/Quotas/utils';
 
-import type { QuotaResourceMetrics } from '@linode/api-v4';
+import type { Quota } from '@linode/api-v4';
 
 interface Props {
   limit: number;
-  resourceMetric: QuotaResourceMetrics;
+  resourceMetric: Quota['resource_metric'];
   usage: number;
 }
 
diff --git a/packages/manager/src/factories/quotas.ts b/packages/manager/src/factories/quotas.ts
index 50d2d2dbc3d..0a3d613e47a 100644
--- a/packages/manager/src/factories/quotas.ts
+++ b/packages/manager/src/factories/quotas.ts
@@ -1,19 +1,43 @@
-import { QuotaResourceMetrics } from '@linode/api-v4/lib/quotas/types';
 import { Factory } from '@linode/utilities';
 
-import type { Quota, QuotaUsage } from '@linode/api-v4/lib/quotas/types';
+import type {
+  LinodeQuota,
+  LkeQuota,
+  ObjectStorageEndpointQuota,
+} from '@linode/api-v4';
+import type { QuotaUsage } from '@linode/api-v4/lib/quotas/types';
 
-export const quotaFactory = Factory.Sync.makeFactory<Quota>({
-  description: 'Maximimum number of vCPUs allowed',
+export const linodeQuotaFactory = Factory.Sync.makeFactory<LinodeQuota>({
+  description: 'Maximum number of vCPUs allowed',
   quota_id: Factory.each((id) => id.toString()),
   quota_limit: 50,
   quota_name: 'Linode Dedicated vCPUs',
-  quota_type: 'linode-dedicated-cpus',
   region_applied: 'us-east',
-  resource_metric: QuotaResourceMetrics.CPU,
-  has_usage: true,
+  resource_metric: 'CPU',
 });
 
+export const lkeQuotaFactory = Factory.Sync.makeFactory<LkeQuota>({
+  description: 'Maximum allowed number of Clusters',
+  quota_id: Factory.each((id) => id.toString()),
+  quota_limit: 50,
+  quota_name: 'LKE Clusters',
+  region_applied: 'us-east',
+  resource_metric: 'cluster',
+});
+
+export const objEndpointQuotaFactory =
+  Factory.Sync.makeFactory<ObjectStorageEndpointQuota>({
+    description: 'Max number of buckets allowed',
+    quota_id: Factory.each((id) => id.toString()),
+    quota_limit: 1000,
+    quota_name: 'Buckets',
+    quota_type: 'obj-buckets',
+    resource_metric: 'bucket',
+    has_usage: true,
+    s3_endpoint: 'endpoint-1.linodeobjects.com',
+    endpoint_type: 'E1',
+  });
+
 export const quotaUsageFactory = Factory.Sync.makeFactory<QuotaUsage>({
   quota_limit: 50,
   usage: 25,
diff --git a/packages/manager/src/features/Account/Quotas/QuotaServicePanel.tsx b/packages/manager/src/features/Account/Quotas/QuotaServicePanel.tsx
new file mode 100644
index 00000000000..1238241f4d5
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/QuotaServicePanel.tsx
@@ -0,0 +1,124 @@
+import { CircleProgress, Notice, Paper, Select, Typography } from '@linode/ui';
+import * as React from 'react';
+
+import { Link } from 'src/components/Link';
+
+import type { QuotaServiceType } from '@linode/api-v4';
+import type { SelectOption } from '@linode/ui';
+import type { Theme } from '@mui/material';
+import type { QuotaService } from 'src/features/Account/Quotas/quotaServices';
+
+type ServiceSelectOption = SelectOption<QuotaServiceType>;
+
+type ServicePanelProps = {
+  availableServices: null | QuotaService[];
+  isFetchingServices: boolean;
+  onServiceChange: (service: null | QuotaService) => void;
+  selectedService: null | QuotaService;
+};
+
+export const QuotaServicePanel: React.FC<ServicePanelProps> = ({
+  availableServices,
+  selectedService,
+  isFetchingServices,
+  onServiceChange,
+}) => {
+  const servicesByType = React.useMemo(() => {
+    if (!availableServices) {
+      return null;
+    }
+    return new Map<QuotaServiceType, QuotaService>(
+      availableServices.map((service) => [service.type, service])
+    );
+  }, [availableServices]);
+
+  const serviceOptions: ServiceSelectOption[] | undefined = React.useMemo(
+    () =>
+      availableServices?.map((service) => ({
+        label: service.label,
+        value: service.type,
+      })) ?? [],
+    [availableServices]
+  );
+
+  const selectedOption = React.useMemo(
+    () =>
+      serviceOptions.find(
+        (service) => service.value === selectedService?.type
+      ) ?? null,
+    [selectedService, serviceOptions]
+  );
+
+  React.useEffect(() => {
+    if (
+      selectedService &&
+      servicesByType &&
+      !servicesByType.has(selectedService.type)
+    ) {
+      onServiceChange(null);
+    }
+  }, [onServiceChange, selectedService, servicesByType]);
+
+  return (
+    <Paper
+      sx={(theme: Theme) => ({
+        marginTop: theme.spacingFunction(16),
+      })}
+      variant="outlined"
+    >
+      {isFetchingServices ? (
+        <div
+          style={{
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+            width: '100%',
+          }}
+        >
+          <CircleProgress size="md" />
+        </div>
+      ) : availableServices?.length === 0 ? (
+        <Typography marginTop={1}>
+          There are no services that have quotas available at this time.
+        </Typography>
+      ) : (
+        <>
+          <Typography>Select a service to view your quotas below.</Typography>
+          <Select<ServiceSelectOption>
+            isOptionEqualToValue={(option, value) =>
+              option.value === value.value
+            }
+            label="Service"
+            onChange={(_event, value) => {
+              if (!value) {
+                onServiceChange(null);
+                return;
+              }
+
+              onServiceChange(servicesByType?.get(value.value) ?? null);
+            }}
+            options={serviceOptions}
+            placeholder="Select a Service"
+            value={selectedOption}
+          />
+          {selectedService?.type === 'object-storage' && (
+            <Notice spacingTop={16} variant="info">
+              <Typography>
+                Details on{' '}
+                <Link to="https://techdocs.akamai.com/cloud-computing/docs/quotas">
+                  {' '}
+                  account Quotas
+                </Link>{' '}
+                and{' '}
+                <Link to="https://techdocs.akamai.com/cloud-computing/docs/object-storage-product-limits">
+                  Object Storage quotas and limits
+                </Link>{' '}
+                can be found in our product documentation.
+              </Typography>
+            </Notice>
+          )}
+        </>
+      )}
+    </Paper>
+  );
+};
diff --git a/packages/manager/src/features/Account/Quotas/Quotas.test.tsx b/packages/manager/src/features/Account/Quotas/Quotas.test.tsx
index 0f1e09932fc..fb82527f60f 100644
--- a/packages/manager/src/features/Account/Quotas/Quotas.test.tsx
+++ b/packages/manager/src/features/Account/Quotas/Quotas.test.tsx
@@ -1,128 +1,125 @@
-import { QueryClient } from '@tanstack/react-query';
-import { screen, waitFor } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
 import * as React from 'react';
 
 import { renderWithTheme } from 'src/utilities/testHelpers';
 
 import { Quotas } from './Quotas';
+import { objectStorageQuotaService } from './quotaServices';
 
-import type { Quota, QuotaUsage } from '@linode/api-v4';
-
-const queryMocks = vi.hoisted(() => ({
-  getQuotasFilters: vi.fn().mockReturnValue({}),
-  getQuotaVisibilityFilter: vi
-    .fn()
-    .mockReturnValue({ isVisible: (quota: Quota) => true }),
-  getQuotaMapper: vi
-    .fn()
-    .mockReturnValue({ mapQuota: (quota: Quota, usage: QuotaUsage) => quota }),
-  useFlags: vi.fn().mockReturnValue({}),
-  useGetLocationsForQuotaService: vi.fn().mockReturnValue({}),
-  useObjectStorageEndpoints: vi.fn().mockReturnValue({}),
-  convertResourceMetric: vi.fn().mockReturnValue({}),
-  pluralizeMetric: vi.fn().mockReturnValue({}),
+const mocks = vi.hoisted(() => ({
+  useQuotaServices: vi.fn(),
+  useNavigate: vi.fn(),
+  useSearch: vi.fn(),
 }));
 
-vi.mock('src/hooks/useFlags', () => {
-  const actual = vi.importActual('src/hooks/useFlags');
-  return {
-    ...actual,
-    useFlags: queryMocks.useFlags,
-  };
-});
+vi.mock('src/features/Account/Quotas/hooks/useQuotaServices', () => ({
+  useQuotaServices: mocks.useQuotaServices,
+}));
 
-vi.mock('@linode/queries', async () => {
-  const actual = await vi.importActual('@linode/queries');
+vi.mock('@tanstack/react-router', async () => {
+  const actual = await vi.importActual('@tanstack/react-router');
   return {
     ...actual,
-    useObjectStorageEndpoints: queryMocks.useObjectStorageEndpoints,
+    useNavigate: mocks.useNavigate,
+    useSearch: mocks.useSearch,
   };
 });
 
-vi.mock('./utils', () => ({
-  getQuotasFilters: queryMocks.getQuotasFilters,
-  getQuotaVisibilityFilter: queryMocks.getQuotaVisibilityFilter,
-  getQuotaMapper: queryMocks.getQuotaMapper,
-  useGetLocationsForQuotaService: queryMocks.useGetLocationsForQuotaService,
-  convertResourceMetric: queryMocks.convertResourceMetric,
-  pluralizeMetric: queryMocks.pluralizeMetric,
-  QUOTA_ROW_MIN_HEIGHT: 58,
+vi.mock('src/features/Account/Quotas/QuotaServicePanel', () => ({
+  QuotaServicePanel: (props: Record<string, any>) => (
+    <div data-testid="quota-service-panel">
+      isFetching:{String(props.isFetchingServices)}
+      selectedService:{String(Boolean(props.selectedService))}
+      availableServicesLength:{String(props.availableServices?.length ?? 0)}
+    </div>
+  ),
+}));
+
+vi.mock('src/features/Account/Quotas/QuotasPanel/QuotasPanel', () => ({
+  QuotasPanel: (props: Record<string, any>) => (
+    <div data-testid="quotas-panel">scope:{String(props.scope)}</div>
+  ),
 }));
 
 describe('Quotas', () => {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: {
-        retry: false,
-      },
-    },
+  beforeEach(() => {
+    mocks.useQuotaServices.mockReset();
+    mocks.useNavigate.mockReset();
+    mocks.useSearch.mockReset();
   });
 
-  it('renders the component with initial state', async () => {
-    const { getByText } = renderWithTheme(<Quotas />, {
-      queryClient,
-    });
+  it('renders loading state when services are being fetched', () => {
+    mocks.useQuotaServices.mockReturnValue({ data: null, isFetching: true });
+    // useSearch not used in this branch but stub anyway
+    mocks.useSearch.mockReturnValue({});
+    mocks.useNavigate.mockReturnValue(vi.fn());
+
+    const { getByTestId, queryByTestId } = renderWithTheme(<Quotas />);
 
-    expect(getByText('Quotas')).toBeInTheDocument();
-    expect(getByText('Learn more about quotas')).toBeInTheDocument();
-    expect(getByText('Object Storage Endpoint')).toBeInTheDocument();
-    expect(
-      screen.getByPlaceholderText('Select an Object Storage S3 endpoint')
-    ).toBeInTheDocument();
-    expect(
-      getByText('Apply filters above to see quotas and current usage.')
-    ).toBeInTheDocument();
+    expect(getByTestId('quota-service-panel')).toHaveTextContent(
+      'isFetching:true'
+    );
+    expect(queryByTestId('quotas-panel')).toBeNull();
   });
 
-  it('allows endpoint selection', async () => {
-    queryMocks.useGetLocationsForQuotaService.mockReturnValue({
-      isFetchingS3Endpoints: false,
-      regions: null,
-      s3Endpoints: [{ label: 'endpoint1 (Standard E0)', value: 'endpoint1' }],
-      service: 'object-storage',
+  it('renders service panel when services available and no service selected', () => {
+    const service = objectStorageQuotaService();
+    mocks.useQuotaServices.mockReturnValue({
+      data: [service],
+      isFetching: false,
     });
+    mocks.useSearch.mockReturnValue({});
+    mocks.useNavigate.mockReturnValue(vi.fn());
 
-    const { getByPlaceholderText, getByRole } = renderWithTheme(<Quotas />, {
-      queryClient,
-    });
+    const { getByTestId, queryByTestId } = renderWithTheme(<Quotas />);
 
-    const endpointSelect = getByPlaceholderText(
-      'Select an Object Storage S3 endpoint'
-    );
+    const panel = getByTestId('quota-service-panel');
+    expect(panel).toHaveTextContent('isFetching:false');
+    expect(panel).toHaveTextContent('selectedService:false');
+    expect(panel).toHaveTextContent('availableServicesLength:1');
 
-    await waitFor(() => {
-      expect(endpointSelect).not.toHaveValue(null);
-    });
+    // no QuotasPanel rendered because no service selected via search
+    expect(queryByTestId('quotas-panel')).toBeNull();
+  });
 
-    await waitFor(() => {
-      expect(endpointSelect).toBeInTheDocument();
+  it('renders QuotasPanel for each available scope when a service is selected via search', () => {
+    const service = objectStorageQuotaService();
+    mocks.useQuotaServices.mockReturnValue({
+      data: [service],
+      isFetching: false,
     });
+    mocks.useSearch.mockReturnValue({ service: service.type });
+    mocks.useNavigate.mockReturnValue(vi.fn());
 
-    await userEvent.click(endpointSelect);
-    await waitFor(async () => {
-      const endpointOption = getByRole('option', {
-        name: 'endpoint1 (Standard E0)',
-      });
-      await userEvent.click(endpointOption);
-    });
+    const { getAllByTestId } = renderWithTheme(<Quotas />);
 
-    await waitFor(() => {
-      expect(endpointSelect).toHaveValue('endpoint1 (Standard E0)');
-    });
+    // objectStorageQuotaService defines scopes that include 'obj-endpoint' (and possibly 'global') depending on flag
+    const panels = getAllByTestId('quotas-panel');
+    // at least one panel should be rendered for the service scopes
+    expect(panels.length).toBeGreaterThanOrEqual(1);
+    // ensure the first panel contains its scope prop
+    expect(panels[0]).toHaveTextContent('scope:');
   });
 
-  it('shows loading state when fetching data', async () => {
-    queryMocks.useGetLocationsForQuotaService.mockReturnValue({
-      isFetchingS3Endpoints: true,
-      s3Endpoints: null,
-      service: 'object-storage',
+  it('resets search if the provided service query param is not available', () => {
+    const service = objectStorageQuotaService();
+    // available services do not include the invalid type
+    mocks.useQuotaServices.mockReturnValue({
+      data: [service],
+      isFetching: false,
     });
+    mocks.useSearch.mockReturnValue({ service: 'unknown-service' });
 
-    const { getByPlaceholderText } = renderWithTheme(<Quotas />, {
-      queryClient,
-    });
+    const navigateMock = vi.fn();
+    mocks.useNavigate.mockReturnValue(navigateMock);
+
+    renderWithTheme(<Quotas />);
 
-    expect(getByPlaceholderText('Loading S3 endpoints...')).toBeInTheDocument();
+    // useEffect should call navigate to update search and clear the invalid service param
+    expect(navigateMock).toHaveBeenCalled();
+    // ensure it was called with an object that includes a `search` function
+    const calledWith = navigateMock.mock.calls[0][0];
+    expect(typeof calledWith.search).toBe('function');
+    // invoking the provided search updater should not throw (it returns an object)
+    expect(() => calledWith.search(() => ({}))).not.toThrow();
   });
 });
diff --git a/packages/manager/src/features/Account/Quotas/Quotas.tsx b/packages/manager/src/features/Account/Quotas/Quotas.tsx
index c5e3560f0f6..6f3ac41c632 100644
--- a/packages/manager/src/features/Account/Quotas/Quotas.tsx
+++ b/packages/manager/src/features/Account/Quotas/Quotas.tsx
@@ -1,151 +1,86 @@
-import {
-  Box,
-  Divider,
-  Notice,
-  Paper,
-  Select,
-  Stack,
-  Typography,
-} from '@linode/ui';
-import { useNavigate } from '@tanstack/react-router';
+import { useNavigate, useSearch } from '@tanstack/react-router';
 import * as React from 'react';
 
 import { DocumentTitleSegment } from 'src/components/DocumentTitle';
-import { Link } from 'src/components/Link';
-import { useFlags } from 'src/hooks/useFlags';
+import { useQuotaServices } from 'src/features/Account/Quotas/hooks/useQuotaServices';
+import { QuotaServicePanel } from 'src/features/Account/Quotas/QuotaServicePanel';
+import { QuotasPanel } from 'src/features/Account/Quotas/QuotasPanel/QuotasPanel';
 
-import { QuotasTable } from './QuotasTable/QuotasTable';
-import { useGetLocationsForQuotaService } from './utils';
-
-import type { Quota } from '@linode/api-v4';
-import type { SelectOption } from '@linode/ui';
-import type { Theme } from '@mui/material';
+import type { QuotaServiceType } from '@linode/api-v4';
+import type {
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
 
 export const Quotas = () => {
-  const navigate = useNavigate();
-  const { objectStorageGlobalQuotas } = useFlags();
-  const [selectedLocation, setSelectedLocation] =
-    React.useState<null | SelectOption<Quota['region_applied']>>(null);
-  const locationData = useGetLocationsForQuotaService('object-storage');
-  const { s3Endpoints } = locationData;
-  const isFetchingLocations =
-    'isFetchingS3Endpoints' in locationData
-      ? locationData.isFetchingS3Endpoints
-      : locationData.isFetchingRegions;
+  const { data: availableServices, isFetching: isFetchingServices } =
+    useQuotaServices();
+  const navigate = useNavigate({ from: '/quotas' });
+  const search = useSearch({ from: '/quotas' });
 
-  const sortedS3Endpoints = React.useMemo(() => {
-    return s3Endpoints?.sort((a, b) => a.label.localeCompare(b.label));
-  }, [s3Endpoints]);
+  const servicesByType = React.useMemo(() => {
+    if (!availableServices) {
+      return null;
+    }
+    return new Map<QuotaServiceType, QuotaService>(
+      availableServices?.map((service) => [service.type, service])
+    );
+  }, [availableServices]);
 
-  return (
-    <>
-      <DocumentTitleSegment segment="Quotas" />
+  const selectedServiceType = (search.service ??
+    null) as null | QuotaServiceType;
+
+  const selectedService = React.useMemo(() => {
+    return selectedServiceType && servicesByType
+      ? (servicesByType.get(selectedServiceType) ?? null)
+      : null;
+  }, [selectedServiceType, servicesByType]);
 
-      {objectStorageGlobalQuotas && (
-        <Paper
-          sx={(theme: Theme) => ({
-            marginTop: theme.spacingFunction(16),
-          })}
-          variant="outlined"
-        >
-          <Typography variant="h2">Object Storage: global</Typography>
+  const updateSearchService = React.useCallback(
+    (service: null | QuotaService) => {
+      navigate({
+        search: (prev) => ({
+          ...prev,
+          service: service ? service.type : undefined,
+        }),
+        replace: true,
+      });
+    },
+    [navigate]
+  );
+
+  // reset service query param if the provided service is not available to the user
+  React.useEffect(() => {
+    if (!isFetchingServices && selectedServiceType && !selectedService) {
+      updateSearchService(null);
+    }
+  }, [
+    isFetchingServices,
+    selectedServiceType,
+    selectedService,
+    updateSearchService,
+  ]);
 
-          <QuotasTable
-            isGlobalScope={true}
-            selectedLocation={null}
-            selectedService={{
-              label: 'Object Storage',
-              value: 'object-storage',
-            }}
-          />
-        </Paper>
-      )}
+  const availableScopes = React.useMemo(() => {
+    return selectedService
+      ? (Object.keys(selectedService.scopes) as QuotaScope[])
+      : [];
+  }, [selectedService]);
 
-      <Paper
-        sx={(theme: Theme) => ({
-          marginTop: theme.spacingFunction(16),
-        })}
-        variant="outlined"
-      >
-        <Stack>
-          <Typography variant="h2">
-            Object Storage{objectStorageGlobalQuotas ? ': per-endpoint' : ''}
-          </Typography>
-          <Box sx={{ display: 'flex' }}>
-            <Notice spacingTop={16} variant="info">
-              <Typography>
-                View your Object Storage quotas by applying the endpoint filter
-                below.{' '}
-                <Link to="https://techdocs.akamai.com/cloud-computing/docs/quotas">
-                  Learn more about quotas
-                </Link>
-                .
-              </Typography>
-            </Notice>
-          </Box>
-          <Stack spacing={1}>
-            <Select
-              disabled={isFetchingLocations}
-              label="Object Storage Endpoint"
-              loading={isFetchingLocations}
-              onChange={(_event, value) => {
-                setSelectedLocation({
-                  label: value?.label,
-                  value: value?.value,
-                });
-                navigate({
-                  to: '/quotas',
-                });
-              }}
-              options={
-                sortedS3Endpoints?.map((location) => ({
-                  label: location.label,
-                  value: location.value,
-                })) ?? []
-              }
-              placeholder={
-                isFetchingLocations
-                  ? `Loading S3 endpoints...`
-                  : 'Select an Object Storage S3 endpoint'
-              }
-              searchable
-              sx={{ flexGrow: 1, mr: 2 }}
-            />
-          </Stack>
-          <Divider spacingBottom={40} spacingTop={40} />
-          <Stack
-            direction="row"
-            justifyContent="space-between"
-            marginBottom={2}
-          >
-            <Typography variant="h3">Quotas</Typography>
-          </Stack>
-          <Typography>
-            If you need to increase a quota, select{' '}
-            <strong>Request Increase</strong> from the Actions menu. Usage can
-            also be found using third-party tools like{' '}
-            <Link to="https://techdocs.akamai.com/cloud-computing/docs/using-s3cmd-with-object-storage#check-disk-usage-by-bucket">
-              s3cmd
-            </Link>
-            .
-          </Typography>
+  return (
+    <>
+      <DocumentTitleSegment segment="Quotas" />
+      <QuotaServicePanel
+        availableServices={availableServices}
+        isFetchingServices={isFetchingServices}
+        onServiceChange={updateSearchService}
+        selectedService={selectedService}
+      />
 
-          <Stack
-            data-testid="endpoint-quotas-table-container"
-            direction="column"
-            spacing={2}
-          >
-            <QuotasTable
-              isGlobalScope={false}
-              selectedLocation={selectedLocation}
-              selectedService={{
-                label: 'Object Storage',
-                value: 'object-storage',
-              }}
-            />
-          </Stack>
-        </Stack>
-      </Paper>
+      {selectedService &&
+        availableScopes.map((scope) => (
+          <QuotasPanel key={scope} scope={scope} service={selectedService} />
+        ))}
     </>
   );
 };
diff --git a/packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.test.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.test.tsx
similarity index 77%
rename from packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.test.tsx
rename to packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.test.tsx
index 9ad895cb3ad..b913fb4d74d 100644
--- a/packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.test.tsx
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.test.tsx
@@ -1,7 +1,8 @@
 import { act, fireEvent, waitFor } from '@testing-library/react';
 import * as React from 'react';
 
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import { linodeQuotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import { linodeQuotaService } from 'src/features/Account/Quotas/quotaServices';
 import { renderWithTheme } from 'src/utilities/testHelpers';
 
 import { QuotasIncreaseForm } from './QuotasIncreaseForm';
@@ -19,18 +20,17 @@ describe('QuotasIncreaseForm', () => {
           onSuccess={() => {}}
           open={true}
           quota={{
-            ...quotaFactory.build(),
+            ...linodeQuotaFactory.build(),
             ...quotaUsageFactory.build(),
           }}
-          selectedService={{
-            label: 'Object Storage',
-            value: 'object-storage',
-          }}
+          scope={'region'}
+          scopeValue={'us-east'}
+          service={linodeQuotaService}
         />
       );
 
     expect(getByLabelText('Title (required)')).toHaveValue(
-      'Increase Object Storage Quota'
+      'Increase Linodes Quota'
     );
     expect(getByLabelText('New Quota (required)')).toHaveValue(0);
     expect(getByText('Current quota in us-east: 100 GB')).toBeInTheDocument();
@@ -55,13 +55,12 @@ describe('QuotasIncreaseForm', () => {
         onSuccess={() => {}}
         open={true}
         quota={{
-          ...quotaFactory.build(),
+          ...linodeQuotaFactory.build(),
           ...quotaUsageFactory.build(),
         }}
-        selectedService={{
-          label: 'Object Storage',
-          value: 'object-storage',
-        }}
+        scope={'region'}
+        scopeValue={'us-east'}
+        service={linodeQuotaService}
       />
     );
 
@@ -80,7 +79,7 @@ describe('QuotasIncreaseForm', () => {
 
     await waitFor(() => {
       expect(previewContent).toHaveTextContent(
-        'Increase Object Storage QuotaUser: mock-user Email: mock-user@linode.com Quota Name: Linode Dedicated vCPUs Current Quota: 100 GB New Quota Requested: 2 GB Needed in: Fewer than 7 days Region: us-east test!'
+        'Increase Linodes QuotaUser: mock-user Email: mock-user@linode.com Quota Name: Linode Dedicated vCPUs Current Quota: 100 GB New Quota Requested: 2 GB Needed in: Fewer than 7 days Region: us-east test!'
       );
     });
   });
diff --git a/packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.tsx
similarity index 92%
rename from packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.tsx
rename to packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.tsx
index dff1302854d..9fddcfaa03b 100644
--- a/packages/manager/src/features/Account/Quotas/QuotasIncreaseForm.tsx
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasIncreaseForm.tsx
@@ -15,10 +15,13 @@ import { Controller, FormProvider, useForm } from 'react-hook-form';
 
 import { Markdown } from 'src/components/Markdown/Markdown';
 
-import { getQuotaIncreaseFormSchema, getQuotaIncreaseMessage } from './utils';
+import { getQuotaIncreaseFormSchema, getQuotaIncreaseMessage } from '../utils';
 
-import type { APIError, Quota, QuotaType, TicketRequest } from '@linode/api-v4';
-import type { SelectOption } from '@linode/ui';
+import type { APIError, Quota, TicketRequest } from '@linode/api-v4';
+import type {
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
 
 interface QuotasIncreaseFormProps {
   convertedResourceMetrics: {
@@ -29,7 +32,9 @@ interface QuotasIncreaseFormProps {
   onSuccess: (ticketId: number) => void;
   open: boolean;
   quota: Quota;
-  selectedService: SelectOption<QuotaType>;
+  scope: QuotaScope;
+  scopeValue: null | string;
+  service: QuotaService;
 }
 
 export interface QuotaIncreaseFormFields extends TicketRequest {
@@ -39,7 +44,14 @@ export interface QuotaIncreaseFormFields extends TicketRequest {
 }
 
 export const QuotasIncreaseForm = (props: QuotasIncreaseFormProps) => {
-  const { onClose, quota, convertedResourceMetrics, selectedService } = props;
+  const {
+    onClose,
+    quota,
+    convertedResourceMetrics,
+    service,
+    scope,
+    scopeValue,
+  } = props;
   const [submitting, setSubmitting] = React.useState<boolean>(false);
   const [error, setError] = React.useState<null | string>(null);
   const formContainerRef = React.useRef<HTMLFormElement>(null);
@@ -54,9 +66,11 @@ export const QuotasIncreaseForm = (props: QuotasIncreaseFormProps) => {
         profile,
         quantity: convertedResourceMetrics?.limit ?? 0,
         quota,
-        selectedService,
+        service,
+        scope,
+        scopeValue,
       }),
-    [quota, profile, selectedService, convertedResourceMetrics]
+    [quota, profile, service, convertedResourceMetrics, scope, scopeValue]
   );
   const form = useForm<QuotaIncreaseFormFields>({
     defaultValues,
@@ -74,7 +88,9 @@ export const QuotasIncreaseForm = (props: QuotasIncreaseFormProps) => {
     profile,
     quantity: Number(quantity),
     quota,
-    selectedService,
+    service,
+    scope,
+    scopeValue,
   }).description;
 
   const handleSubmit = form.handleSubmit(async (values) => {
@@ -130,7 +146,7 @@ export const QuotasIncreaseForm = (props: QuotasIncreaseFormProps) => {
               <Stack direction="row" gap={2}>
                 <TextField
                   errorText={fieldState.error?.message}
-                  helperText={`Current quota in ${quota.region_applied || quota.s3_endpoint}: ${convertedResourceMetrics?.limit?.toLocaleString() ?? 'unknown'} ${convertedResourceMetrics?.metric}`}
+                  helperText={`Current quota${scopeValue ? ` in ${scopeValue}` : ''}: ${convertedResourceMetrics?.limit?.toLocaleString() ?? 'unknown'} ${convertedResourceMetrics?.metric}`}
                   label="New Quota"
                   min={convertedResourceMetrics?.limit}
                   name="quantity"
diff --git a/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.test.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.test.tsx
new file mode 100644
index 00000000000..954ceb49a20
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.test.tsx
@@ -0,0 +1,54 @@
+import userEvent from '@testing-library/user-event';
+import * as React from 'react';
+
+import {
+  linodeQuotaService,
+  objectStorageQuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
+import { renderWithTheme } from 'src/utilities/testHelpers';
+
+import { QuotasPanel } from './QuotasPanel';
+
+vi.mock('./QuotasTable', () => ({
+  QuotasTable: (props: Record<string, any>) => (
+    <div data-testid="mock-table">scopeValue:{String(props.scopeValue)}</div>
+  ),
+}));
+
+vi.mock('./ScopeValueSelect', () => ({
+  ScopeValueSelect: (props: Record<string, any>) => (
+    <button data-testid="mock-select" onClick={() => props.onChange('us-east')}>
+      mock-select
+    </button>
+  ),
+}));
+
+describe('QuotasPanel', () => {
+  it('renders global scope without selector and shows table', () => {
+    const { getByText, queryByTestId, getByTestId } = renderWithTheme(
+      <QuotasPanel scope={'global'} service={objectStorageQuotaService()} />
+    );
+
+    expect(getByText('Object Storage: global')).toBeInTheDocument();
+    // No selector for global scope
+    expect(queryByTestId('mock-select')).toBeNull();
+    // Table is still rendered
+    expect(getByTestId('mock-table')).toBeInTheDocument();
+  });
+
+  it('renders non-global scope with selector and updates scopeValue', async () => {
+    const { getByText, getByTestId } = renderWithTheme(
+      <QuotasPanel scope={'region'} service={linodeQuotaService} />
+    );
+
+    expect(getByText('Linodes: per-region')).toBeInTheDocument();
+    expect(
+      getByText('View your Linodes quotas by applying the region filter below.')
+    ).toBeInTheDocument();
+
+    const select = getByTestId('mock-select');
+    await userEvent.click(select);
+
+    expect(getByTestId('mock-table')).toHaveTextContent('scopeValue:us-east');
+  });
+});
diff --git a/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.tsx
new file mode 100644
index 00000000000..061f6b70643
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasPanel.tsx
@@ -0,0 +1,94 @@
+import { Divider, Paper, Stack, Typography } from '@linode/ui';
+import * as React from 'react';
+
+import { Link } from 'src/components/Link';
+import { QuotasTable } from 'src/features/Account/Quotas/QuotasPanel/QuotasTable';
+import { ScopeValueSelect } from 'src/features/Account/Quotas/QuotasPanel/ScopeValueSelect';
+
+import type { Theme } from '@mui/material';
+import type {
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
+
+interface QuotasPanelProps {
+  scope: QuotaScope;
+  service: QuotaService;
+}
+
+const quotaLabels: Record<QuotaScope, string> = {
+  global: 'global',
+  region: 'region',
+  'obj-endpoint': 'endpoint',
+};
+
+export const QuotasPanel: React.FC<QuotasPanelProps> = ({ service, scope }) => {
+  const [scopeValue, setScopeValue] = React.useState<null | string>(null);
+
+  // reset scope value in case scope or service changes
+  React.useEffect(() => {
+    setScopeValue(null);
+  }, [scope, service]);
+
+  return (
+    <Paper
+      sx={(theme: Theme) => ({
+        marginTop: theme.spacingFunction(16),
+      })}
+      variant="outlined"
+    >
+      <Typography variant="h2">
+        {service.label}:{' '}
+        {`${scope === 'global' ? '' : 'per-'}${quotaLabels[scope]}`}
+      </Typography>
+
+      {scope !== 'global' && (
+        <>
+          <Typography marginBottom={2} marginTop={2}>
+            View your {service.label} quotas by applying the{' '}
+            {quotaLabels[scope]} filter below.
+          </Typography>
+
+          <Stack spacing={1}>
+            <ScopeValueSelect
+              additionalProps={service.scopes[scope]?.scopeValueSelectorProps}
+              data-testid="scope-value-select"
+              onChange={(value) => setScopeValue(value)}
+              scope={scope}
+              sx={{ flexGrow: 1, mr: 2 }}
+            />
+          </Stack>
+
+          <Divider spacingBottom={40} spacingTop={40} />
+
+          <Stack
+            direction="row"
+            justifyContent="space-between"
+            marginBottom={2}
+          >
+            <Typography variant="h3">Quotas</Typography>
+          </Stack>
+
+          {scope === 'obj-endpoint' ? (
+            <Typography>
+              If you need to increase a quota, select{' '}
+              <strong>Request Increase</strong> from the Actions menu. Usage can
+              also be found using third-party tools like{' '}
+              <Link to="https://techdocs.akamai.com/cloud-computing/docs/using-s3cmd-with-object-storage#check-disk-usage-by-bucket">
+                s3cmd
+              </Link>
+              .
+            </Typography>
+          ) : (
+            <Typography>
+              If you need to increase a quota, select{' '}
+              <strong>Request Increase</strong> from the Actions menu.
+            </Typography>
+          )}
+        </>
+      )}
+
+      <QuotasTable scope={scope} scopeValue={scopeValue} service={service} />
+    </Paper>
+  );
+};
diff --git a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.test.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.test.tsx
similarity index 81%
rename from packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.test.tsx
rename to packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.test.tsx
index 7b632367ace..35880e56caf 100644
--- a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.test.tsx
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.test.tsx
@@ -1,8 +1,15 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import { waitFor } from '@testing-library/react';
 import * as React from 'react';
 
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import {
+  linodeQuotaFactory,
+  objEndpointQuotaFactory,
+  quotaUsageFactory,
+} from 'src/factories/quotas';
+import {
+  linodeQuotaService,
+  objectStorageQuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
 import { renderWithTheme } from 'src/utilities/testHelpers';
 
 import { QuotasTable } from './QuotasTable';
@@ -42,12 +49,9 @@ describe('QuotasTable', () => {
   it('should render', async () => {
     const { getByRole, getByTestId, getByText } = renderWithTheme(
       <QuotasTable
-        isGlobalScope={false}
-        selectedLocation={null}
-        selectedService={{
-          label: 'Linodes',
-          value: 'linode',
-        }}
+        scope={'region'}
+        scopeValue={null}
+        service={linodeQuotaService}
       />
     );
     expect(
@@ -65,7 +69,7 @@ describe('QuotasTable', () => {
 
   it('should render a table with the correct data', async () => {
     const quotas = [
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description: 'Random Quota Description',
         quota_limit: 100,
         quota_name: 'Random Quota',
@@ -93,15 +97,9 @@ describe('QuotasTable', () => {
 
     const { getByLabelText, getByTestId, getByText } = renderWithTheme(
       <QuotasTable
-        isGlobalScope={false}
-        selectedLocation={{
-          label: 'NJ',
-          value: 'us-east',
-        }}
-        selectedService={{
-          label: 'Linodes',
-          value: 'linode',
-        }}
+        scope={'region'}
+        scopeValue={'us-east'}
+        service={linodeQuotaService}
       />
     );
 
@@ -123,16 +121,16 @@ describe('QuotasTable', () => {
     });
   });
 
-  it('should display object storage thoughput quotas correctly', async () => {
+  it('should display object storage throughput quotas correctly', async () => {
     queryMocks.useAllQuotasQuery.mockReturnValue({
       data: [
-        quotaFactory.build({
+        objEndpointQuotaFactory.build({
           quota_name: 'Ingress Throughput (per endpoint)',
           description:
             'Current total ingress bandwidth per account, per endpoint',
           quota_limit: 1250000000,
           quota_type: 'obj-total-ingress-throughput',
-          resource_metric: QuotaResourceMetrics.BYTE_PER_SECOND,
+          resource_metric: 'byte_per_second',
           has_usage: false,
         }),
       ],
@@ -151,15 +149,9 @@ describe('QuotasTable', () => {
 
     const { getByLabelText, getByText } = renderWithTheme(
       <QuotasTable
-        isGlobalScope={false}
-        selectedLocation={{
-          label: 'NJ',
-          value: 'us-east',
-        }}
-        selectedService={{
-          label: 'Object Storage',
-          value: 'object-storage',
-        }}
+        scope={'obj-endpoint'}
+        scopeValue={'endpoint.linodeobjects.com'}
+        service={objectStorageQuotaService()}
       />
     );
 
diff --git a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.tsx
similarity index 64%
rename from packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.tsx
rename to packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.tsx
index d25ee8b408c..d10bd0621f2 100644
--- a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTable.tsx
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTable.tsx
@@ -1,4 +1,4 @@
-import { Dialog, ErrorState } from '@linode/ui';
+import { Dialog, ErrorState, Stack } from '@linode/ui';
 import { useNavigate } from '@tanstack/react-router';
 import * as React from 'react';
 
@@ -10,27 +10,31 @@ import { TableRow } from 'src/components/TableRow/TableRow';
 import { TableRowEmpty } from 'src/components/TableRowEmpty/TableRowEmpty';
 import { TableRowLoading } from 'src/components/TableRowLoading/TableRowLoading';
 
-import { useGetQuotas } from '../hooks/useGetQuotas';
-import { QuotasIncreaseForm } from '../QuotasIncreaseForm';
-import { QUOTA_ROW_MIN_HEIGHT } from '../utils';
+import { useQuotasWithUsageQuery } from '../hooks/useQuotasWithUsageQuery';
+import { QuotasIncreaseForm } from './QuotasIncreaseForm';
 import { QuotasTableRow } from './QuotasTableRow';
 
-import type { Quota, QuotaType } from '@linode/api-v4';
-import type { SelectOption } from '@linode/ui';
+import type { Quota } from '@linode/api-v4';
+import type {
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
 import type { AttachmentError } from 'src/features/Support/SupportTicketDetail/SupportTicketDetail';
 
 interface QuotasTableProps {
-  isGlobalScope: boolean;
-  selectedLocation: null | SelectOption<Quota['region_applied']>;
-  selectedService: SelectOption<QuotaType>;
+  scope: QuotaScope;
+  scopeValue: null | string;
+  service: QuotaService;
 }
 
+const QUOTA_ROW_MIN_HEIGHT = 58;
+
 export const QuotasTable = (props: QuotasTableProps) => {
-  const { selectedLocation, selectedService, isGlobalScope } = props;
+  const { scopeValue, service, scope } = props;
   const navigate = useNavigate();
 
-  const hasSelectedLocation = Boolean(selectedLocation?.value);
-  const collectionName = isGlobalScope ? 'global-quotas' : 'quotas';
+  const isScopeValueProvided = Boolean(scopeValue);
+  const isGlobalScope = scope === 'global';
 
   const [supportModalOpen, setSupportModalOpen] = React.useState(false);
   const [selectedQuota, setSelectedQuota] = React.useState<Quota | undefined>();
@@ -45,20 +49,24 @@ export const QuotasTable = (props: QuotasTableProps) => {
 
   const {
     data: quotasWithUsage,
-    errorMessage: quotasErrorMessage,
-    queries: quotaUsageQueries,
+    error: quotasError,
     isFetching: isFetchingQuotas,
-  } = useGetQuotas({
-    selectedLocation: selectedLocation?.value,
-    selectedService: selectedService.value,
-    collectionName,
-    enabled: isGlobalScope ? true : hasSelectedLocation,
+  } = useQuotasWithUsageQuery({
+    service,
+    scope,
+    scopeValue,
+    enabled: isGlobalScope || isScopeValueProvided,
   });
 
-  const isNotFoundErrorIgnored = quotasErrorMessage === 'Not found';
+  const testId = `quotas-table-${scope}`;
 
-  if (quotasErrorMessage && !isNotFoundErrorIgnored) {
-    return <ErrorState errorText={quotasErrorMessage} />;
+  if (quotasError) {
+    return (
+      <Stack data-testid={testId}>
+        {' '}
+        <ErrorState errorText={quotasError} />;{' '}
+      </Stack>
+    );
   }
 
   const onIncreaseQuotaTicketCreated = (
@@ -78,7 +86,7 @@ export const QuotasTable = (props: QuotasTableProps) => {
   return (
     <>
       <Table
-        data-testid="table-endpoint-quotas"
+        data-testid={testId}
         sx={(theme) => ({
           marginTop: theme.spacingFunction(16),
           minWidth: theme.breakpoints.values.sm,
@@ -96,40 +104,28 @@ export const QuotasTable = (props: QuotasTableProps) => {
           {isFetchingQuotas ? (
             <TableRowLoading
               columns={4}
-              rows={isGlobalScope ? 1 : 3}
+              rows={1}
               sx={{ height: QUOTA_ROW_MIN_HEIGHT }}
             />
-          ) : !isGlobalScope && !hasSelectedLocation ? (
+          ) : !isGlobalScope && !isScopeValueProvided ? (
             <TableRowEmpty
               colSpan={4}
               message="Apply filters above to see quotas and current usage."
               sx={{ height: QUOTA_ROW_MIN_HEIGHT }}
             />
-          ) : isNotFoundErrorIgnored ? (
-            <TableRowEmpty
-              colSpan={4}
-              message="No quotas to display."
-              sx={{ height: QUOTA_ROW_MIN_HEIGHT }}
-            />
           ) : quotasWithUsage.length === 0 ? (
             <TableRowEmpty
               colSpan={4}
-              message="There is no data available for this service and region."
+              message="No quotas to display."
               sx={{ height: QUOTA_ROW_MIN_HEIGHT }}
             />
           ) : (
-            quotasWithUsage.map((quota, index) => {
+            quotasWithUsage.map((quotaWithUsage, index) => {
               return (
                 <QuotasTableRow
-                  hasUsage={
-                    quota.has_usage === true || quota.has_usage === undefined
-                  }
-                  index={index}
-                  isDataPresent={quota.usage?.usage !== null}
-                  key={quota.quota_id}
-                  quota={quota}
+                  key={quotaWithUsage.quota.quota_id}
                   quotaRowMinHeight={QUOTA_ROW_MIN_HEIGHT}
-                  quotaUsageQueries={quotaUsageQueries}
+                  quotaWithUsage={quotaWithUsage}
                   setConvertedResourceMetrics={setConvertedResourceMetrics}
                   setSelectedQuota={setSelectedQuota}
                   setSupportModalOpen={setSupportModalOpen}
@@ -149,7 +145,7 @@ export const QuotasTable = (props: QuotasTableProps) => {
             width: '100%',
           },
         }}
-        title={`Contact Support: Increase ${selectedService.label} Quota`}
+        title={`Contact Support: Increase ${service.label} Quota`}
       >
         {selectedQuota && (
           <QuotasIncreaseForm
@@ -158,7 +154,9 @@ export const QuotasTable = (props: QuotasTableProps) => {
             onSuccess={onIncreaseQuotaTicketCreated}
             open={supportModalOpen}
             quota={selectedQuota}
-            selectedService={selectedService}
+            scope={scope}
+            scopeValue={scopeValue}
+            service={service}
           />
         )}
       </Dialog>
diff --git a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTableRow.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTableRow.tsx
similarity index 79%
rename from packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTableRow.tsx
rename to packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTableRow.tsx
index be75ef10bb5..91bb6d6b80b 100644
--- a/packages/manager/src/features/Account/Quotas/QuotasTable/QuotasTableRow.tsx
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/QuotasTableRow.tsx
@@ -1,5 +1,4 @@
 import { Box, CircleProgress, TooltipIcon, Typography } from '@linode/ui';
-import ErrorOutline from '@mui/icons-material/ErrorOutline';
 import * as React from 'react';
 
 import { ActionMenu } from 'src/components/ActionMenu/ActionMenu';
@@ -9,20 +8,15 @@ import { TableRow } from 'src/components/TableRow/TableRow';
 import { useFlags } from 'src/hooks/useFlags';
 import { useIsAkamaiAccount } from 'src/hooks/useIsAkamaiAccount';
 
-import { convertResourceMetric, getQuotaError } from '../utils';
+import { convertResourceMetric } from '../utils';
 
 import type { QuotaWithUsage } from '../utils';
-import type { Quota, QuotaUsage } from '@linode/api-v4';
-import type { UseQueryResult } from '@tanstack/react-query';
+import type { Quota } from '@linode/api-v4';
 import type { Action } from 'src/components/ActionMenu/ActionMenu';
 
 interface QuotasTableRowProps {
-  hasUsage: boolean;
-  index: number;
-  isDataPresent: boolean;
-  quota: QuotaWithUsage;
   quotaRowMinHeight: number;
-  quotaUsageQueries: UseQueryResult<QuotaUsage, Error>[];
+  quotaWithUsage: QuotaWithUsage;
   setConvertedResourceMetrics: (resourceMetric: {
     limit: number;
     metric: string;
@@ -33,19 +27,15 @@ interface QuotasTableRowProps {
 
 export const QuotasTableRow = (props: QuotasTableRowProps) => {
   const {
-    hasUsage,
-    isDataPresent,
-    index,
-    quota,
+    quotaWithUsage,
     quotaRowMinHeight,
-    quotaUsageQueries,
     setSelectedQuota,
     setSupportModalOpen,
     setConvertedResourceMetrics,
   } = props;
   const flags = useFlags();
   const { isAkamaiAccount } = useIsAkamaiAccount();
-  // These conditions are meant to achieve a couple things:
+  // These conditions are meant to achieve a couple of things:
   // 1. Ability to disable the request for increase button for Internal accounts (this will be used for early adopters, and removed eventually).
   // 2. Ability to disable the request for increase button for All accounts (this is a prevention measure when beta is in GA).
   const isRequestForQuotaButtonDisabled =
@@ -53,16 +43,18 @@ export const QuotasTableRow = (props: QuotasTableRowProps) => {
     (flags.limitsEvolution?.requestForIncreaseDisabledForInternalAccountsOnly &&
       isAkamaiAccount);
 
+  const quota = quotaWithUsage.quota;
+
   const { convertedLimit, convertedResourceMetric } = convertResourceMetric({
     initialResourceMetric: quota.resource_metric,
-    initialUsage: quota.usage?.usage ?? 0,
+    initialUsage: quotaWithUsage.usage ?? 0,
     initialLimit: quota.quota_limit,
   });
 
   const requestIncreaseAction: Action = {
     disabled: isRequestForQuotaButtonDisabled,
     onClick: () => {
-      setSelectedQuota(quota);
+      setSelectedQuota(quotaWithUsage.quota);
       setSupportModalOpen(true);
       setConvertedResourceMetrics({
         limit: Number(convertedLimit),
@@ -101,12 +93,12 @@ export const QuotasTableRow = (props: QuotasTableRowProps) => {
       </TableCell>
       <TableCell>
         <Box sx={{ maxWidth: '80%' }}>
-          {quotaUsageQueries[index]?.isLoading ? (
+          {quotaWithUsage.isFetchingUsage ? (
             <Box alignItems="center" display="flex" gap={1}>
               <CircleProgress size="sm" />{' '}
-              <Typography>Fetching Data...</Typography>
+              <Typography>Fetching data...</Typography>
             </Box>
-          ) : quotaUsageQueries[index]?.error ? (
+          ) : quotaWithUsage.fetchingUsageFailed ? (
             <Typography
               sx={{
                 alignItems: 'center',
@@ -115,16 +107,23 @@ export const QuotasTableRow = (props: QuotasTableRowProps) => {
                 lineHeight: 1,
               }}
             >
-              <ErrorOutline />
-              {getQuotaError(quotaUsageQueries, index)}
+              <TooltipIcon
+                status="warning"
+                sxTooltipIcon={{ padding: `0px 0px` }}
+                text={
+                  quotaWithUsage.usageFetchErrorMessage ??
+                  'An unexpected error occurred.'
+                }
+              />
+              Failed to fetch data
             </Typography>
-          ) : hasUsage && isDataPresent ? (
+          ) : quotaWithUsage.usage !== null ? (
             <QuotaUsageBar
               limit={quota.quota_limit}
               resourceMetric={quota.resource_metric}
-              usage={quota.usage?.usage ?? 0}
+              usage={quotaWithUsage.usage}
             />
-          ) : hasUsage ? (
+          ) : quotaWithUsage.hasUsage ? (
             <Typography>Data not available</Typography>
           ) : (
             <Typography>Not applicable</Typography>
diff --git a/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.test.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.test.tsx
new file mode 100644
index 00000000000..7bb93f76fb5
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.test.tsx
@@ -0,0 +1,105 @@
+import { regionFactory } from '@linode/utilities';
+import { waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import * as React from 'react';
+
+import { objectStorageEndpointsFactory } from 'src/factories';
+import { renderWithTheme } from 'src/utilities/testHelpers';
+
+import { ScopeValueSelect } from './ScopeValueSelect';
+
+const mocks = vi.hoisted(() => ({
+  useFlags: vi.fn().mockReturnValue({}),
+  useIsGeckoEnabled: vi.fn().mockReturnValue({ isGeckoLAEnabled: true }),
+  useRegionsQuery: vi.fn().mockReturnValue({}),
+  useObjectStorageEndpoints: vi.fn().mockReturnValue({}),
+}));
+
+vi.mock('src/hooks/useFlags', () => ({
+  useFlags: mocks.useFlags,
+}));
+
+vi.mock('@linode/shared', () => ({
+  useIsGeckoEnabled: mocks.useIsGeckoEnabled,
+}));
+
+vi.mock('@linode/queries', async () => {
+  const actual = await vi.importActual('@linode/queries');
+  return {
+    ...actual,
+    useRegionsQuery: mocks.useRegionsQuery,
+  };
+});
+
+vi.mock('src/queries/object-storage/queries', () => ({
+  useObjectStorageEndpoints: mocks.useObjectStorageEndpoints,
+}));
+
+describe('ScopeValueSelect', () => {
+  it('renders region select and calls onChange with selected region', async () => {
+    mocks.useRegionsQuery.mockReturnValue({
+      data: [
+        regionFactory.build({
+          id: 'us-east',
+          label: 'Newark, NJ',
+          capabilities: ['Linodes'],
+        }),
+      ],
+    });
+
+    const onChange = vi.fn();
+
+    const { getByPlaceholderText, getByRole } = renderWithTheme(
+      <ScopeValueSelect
+        additionalProps={{ regionCapability: 'Linodes' }}
+        onChange={onChange}
+        scope={'region'}
+      />
+    );
+
+    const regionSelect = getByPlaceholderText('Select a Region');
+    await userEvent.click(regionSelect);
+
+    await waitFor(async () => {
+      const option = getByRole('option', { name: 'Newark, NJ (us-east)' });
+      await userEvent.click(option);
+    });
+
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalledWith('us-east');
+    });
+  });
+
+  it('renders object storage endpoint select and calls onChange with selected endpoint', async () => {
+    mocks.useObjectStorageEndpoints.mockReturnValue({
+      data: [
+        objectStorageEndpointsFactory.build({
+          s3_endpoint: 'endpoint1',
+          endpoint_type: 'E0',
+        }),
+      ],
+    });
+
+    const onChange = vi.fn();
+
+    const { getByPlaceholderText, getByRole } = renderWithTheme(
+      <ScopeValueSelect
+        additionalProps={{}}
+        onChange={onChange}
+        scope={'obj-endpoint'}
+      />
+    );
+
+    const select = getByPlaceholderText('Select an Object Storage endpoint');
+    await userEvent.click(select);
+
+    await waitFor(async () => {
+      const option = getByRole('option', { name: 'endpoint1 (Standard E0)' });
+      await userEvent.click(option);
+    });
+
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalledWith('endpoint1');
+    });
+  });
+});
diff --git a/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.tsx b/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.tsx
new file mode 100644
index 00000000000..cb695313621
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/QuotasPanel/ScopeValueSelect.tsx
@@ -0,0 +1,85 @@
+import { useRegionsQuery } from '@linode/queries';
+import { useIsGeckoEnabled } from '@linode/shared';
+import { Select } from '@linode/ui';
+import * as React from 'react';
+
+import { RegionSelect } from 'src/components/RegionSelect/RegionSelect';
+import { useFlags } from 'src/hooks/useFlags';
+import { useObjectStorageEndpoints } from 'src/queries/object-storage/queries';
+
+import type { SelectOption, SelectProps } from '@linode/ui';
+import type {
+  QuotaScope,
+  ScopeValueSelectorProps,
+} from 'src/features/Account/Quotas/quotaServices';
+
+type EndpointSelectOption = SelectOption<string>;
+
+interface ScopeValueSelectProps {
+  additionalProps: ScopeValueSelectorProps | undefined;
+  onChange: (value: null | string) => void;
+  scope: Omit<QuotaScope, 'global'>;
+  sx?: SelectProps<any>['sx'];
+}
+
+export const ScopeValueSelect: React.FC<ScopeValueSelectProps> = ({
+  scope,
+  onChange,
+  sx,
+  additionalProps = {},
+}) => {
+  const flags = useFlags();
+  const { isGeckoLAEnabled } = useIsGeckoEnabled(
+    flags.gecko2?.enabled,
+    flags.gecko2?.la
+  );
+
+  const { data: regions, isFetching: isFetchingRegions } = useRegionsQuery(
+    scope === 'region'
+  );
+  const { data: endpoints, isFetching: isFetchingEndpoints } =
+    useObjectStorageEndpoints(scope === 'obj-endpoint');
+
+  const sortedEndpoints: EndpointSelectOption[] = React.useMemo(() => {
+    return (endpoints ?? [])
+      .filter((endpoint) => endpoint.s3_endpoint !== null)
+      .map((endpoint) => ({
+        label: `${endpoint.s3_endpoint} (Standard ${endpoint.endpoint_type})`,
+        value: endpoint.s3_endpoint as string,
+      }))
+      .sort((a, b) => a.label.localeCompare(b.label));
+  }, [endpoints]);
+
+  if (scope === 'obj-endpoint') {
+    return (
+      <Select<EndpointSelectOption>
+        data-testid="endpoint-select"
+        disabled={isFetchingEndpoints}
+        label="Object Storage Endpoint"
+        loading={isFetchingEndpoints}
+        onChange={(_event, value) => onChange(value?.value ?? null)}
+        options={sortedEndpoints}
+        placeholder={
+          isFetchingEndpoints
+            ? 'Loading Object Storage endpoints...'
+            : 'Select an Object Storage endpoint'
+        }
+        searchable
+        sx={sx}
+      />
+    );
+  }
+
+  return (
+    <RegionSelect
+      currentCapability={additionalProps?.regionCapability}
+      data-testid="region-select"
+      disabled={isFetchingRegions}
+      isGeckoLAEnabled={isGeckoLAEnabled}
+      loading={isFetchingRegions}
+      onChange={(_, region) => onChange(region?.id ?? null)}
+      regions={regions ?? []}
+      value={null}
+    />
+  );
+};
diff --git a/packages/manager/src/features/Account/Quotas/hooks/useGetQuotas.ts b/packages/manager/src/features/Account/Quotas/hooks/useGetQuotas.ts
deleted file mode 100644
index c451995bc23..00000000000
--- a/packages/manager/src/features/Account/Quotas/hooks/useGetQuotas.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { quotaQueries, useAllQuotasQuery, useQueries } from '@linode/queries';
-import * as React from 'react';
-
-import {
-  getQuotaMapper,
-  getQuotasFilters,
-  getQuotaVisibilityFilter,
-} from 'src/features/Account/Quotas/utils';
-
-import type { Filter, QuotaType } from '@linode/api-v4';
-
-interface Props {
-  collectionName: string;
-  enabled: boolean;
-  selectedLocation: string;
-  selectedService: QuotaType;
-}
-
-export const useGetQuotas = ({
-  selectedLocation,
-  selectedService,
-  collectionName,
-  enabled = true,
-}: Props) => {
-  const filters: Filter = getQuotasFilters({
-    location: { label: '', value: selectedLocation },
-    service: { label: '', value: selectedService },
-  });
-
-  const visiblityFilter = getQuotaVisibilityFilter(selectedService);
-  const quotaMapper = getQuotaMapper(selectedService);
-
-  const {
-    data: quotas,
-    error: quotasError,
-    isError: isQuotasError,
-    isFetching: isFetchingQuotas,
-  } = useAllQuotasQuery(selectedService, collectionName, {}, filters, enabled);
-
-  // Quota Usage Queries
-  // For each quota with has_usage == true,
-  // fetch the usage in parallel
-  // This will only fetch for the paginated set
-  const quotaIdsHavingUsage =
-    quotas
-      ?.filter(
-        (quota) => quota.has_usage === true || quota.has_usage === undefined
-      )
-      .map((quota) => quota.quota_id) ?? [];
-  const quotaUsageQueries = useQueries({
-    queries: quotaIdsHavingUsage.map((quotaId) =>
-      quotaQueries.service(selectedService, collectionName)._ctx.usage(quotaId)
-    ),
-  });
-
-  // Combine the quotas with their usage
-  const filteredQuotasWithUsage = React.useMemo(
-    () =>
-      quotas
-        ?.filter((quota) => visiblityFilter.isVisible(quota))
-        .map((quota, index) =>
-          quotaMapper.mapQuota(quota, quotaUsageQueries?.[index]?.data || null)
-        ) ?? [],
-    [quotas, quotaUsageQueries]
-  );
-
-  return {
-    data: filteredQuotasWithUsage,
-    queries: quotaUsageQueries,
-    errorMessage:
-      (quotasError && quotasError[0]?.reason) ||
-      quotaUsageQueries.find((query) => query.isError)?.error.message,
-    isError: isQuotasError || quotaUsageQueries.some((query) => query.isError),
-    isFetching:
-      isFetchingQuotas || quotaUsageQueries.some((query) => query.isFetching),
-  };
-};
diff --git a/packages/manager/src/features/Account/Quotas/hooks/useQuotaServices.ts b/packages/manager/src/features/Account/Quotas/hooks/useQuotaServices.ts
new file mode 100644
index 00000000000..5f11cd30c75
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/hooks/useQuotaServices.ts
@@ -0,0 +1,36 @@
+import { useAccountSettings, useProfile } from '@linode/queries';
+import { useFlags } from 'launchdarkly-react-client-sdk';
+import { useMemo } from 'react';
+
+import { objectStorageQuotaService } from 'src/features/Account/Quotas/quotaServices';
+
+import type { QuotaService } from 'src/features/Account/Quotas/quotaServices';
+
+export interface UseQuotaServicesResult {
+  data: null | QuotaService[];
+  isFetching: boolean;
+}
+
+export const useQuotaServices = (): UseQuotaServicesResult => {
+  const { objectStorageGlobalQuotas } = useFlags();
+  const { data: profile, isFetching: isFetchingProfile } = useProfile();
+  const { data: accountSettings, isFetching: isFetchingAccountSettings } =
+    useAccountSettings();
+
+  const result = useMemo(() => {
+    const result: QuotaService[] = [];
+    if (
+      profile &&
+      !profile.restricted &&
+      accountSettings?.object_storage === 'active'
+    ) {
+      result.push(objectStorageQuotaService(objectStorageGlobalQuotas));
+    }
+    return result;
+  }, [objectStorageGlobalQuotas, profile, accountSettings]);
+
+  return {
+    data: result,
+    isFetching: isFetchingProfile || isFetchingAccountSettings,
+  };
+};
diff --git a/packages/manager/src/features/Account/Quotas/hooks/useQuotasWithUsageQuery.ts b/packages/manager/src/features/Account/Quotas/hooks/useQuotasWithUsageQuery.ts
new file mode 100644
index 00000000000..4ab390560a8
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/hooks/useQuotasWithUsageQuery.ts
@@ -0,0 +1,120 @@
+import { useAllQuotasQuery, useQuotaUsageQueries } from '@linode/queries';
+import * as React from 'react';
+
+import type { APIError, Filter, QuotaUsage } from '@linode/api-v4';
+import type { UseQueryResult } from '@tanstack/react-query';
+import type {
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
+import type { QuotaWithUsage } from 'src/features/Account/Quotas/utils';
+
+interface QuotasWithUsageQueryProps {
+  enabled: boolean;
+  scope: QuotaScope;
+  scopeValue: null | string;
+  service: QuotaService;
+}
+
+interface QuotasWithUsageQueryResult {
+  data: QuotaWithUsage[];
+  error: null | string;
+  isError: boolean;
+  isFetching: boolean;
+}
+
+export const useQuotasWithUsageQuery = ({
+  service,
+  scope,
+  scopeValue,
+  enabled = true,
+}: QuotasWithUsageQueryProps): QuotasWithUsageQueryResult => {
+  // The provided scope should always be supported by the provided service, but just
+  // for the sake of error handling, fallback to a default scope if it's not
+  const scopeDefinition = service.scopes[scope] ?? { apiCollection: 'quotas' };
+
+  const apiFilter: Filter = React.useMemo(() => {
+    return (
+      (scopeValue ? scopeDefinition?.apiFilterFunction?.(scopeValue) : null) ??
+      {}
+    );
+  }, [scopeDefinition, scopeValue]);
+
+  const {
+    data: quotas,
+    error: quotasError,
+    isFetching: isFetchingQuotas,
+    isError: isQuotasFetchError,
+  } = useAllQuotasQuery(
+    service.type,
+    scopeDefinition.apiCollection,
+    apiFilter,
+    enabled
+  );
+
+  // For each quota providing usage, fetch the usage in parallel
+  const quotaIdsHavingUsage = React.useMemo(
+    () =>
+      quotas
+        ?.filter((quota) => ('has_usage' in quota ? quota.has_usage : true))
+        .map((quota) => quota.quota_id) ?? [],
+    [quotas]
+  );
+
+  const quotaUsageQueries = useQuotaUsageQueries(
+    service.type,
+    scopeDefinition.apiCollection,
+    quotaIdsHavingUsage,
+    enabled
+  );
+
+  const usageQueryByQuotaId = React.useMemo(() => {
+    const map = new Map<string, UseQueryResult<QuotaUsage, APIError[]>>();
+    quotaIdsHavingUsage.forEach((quotaId, i) => {
+      const usageQuery = quotaUsageQueries[i];
+      if (usageQuery) {
+        map.set(quotaId, usageQuery);
+      }
+    });
+    return map;
+  }, [quotaIdsHavingUsage, quotaUsageQueries]);
+
+  // calculate the fingerprint of the usage queries to use as a dependency for the quotasWithUsage memo.
+  const usageQueriesFingerprint = quotaUsageQueries
+    .map((query) => `${query.data?.usage ?? ''}&${query.isError ? 1 : 0}`)
+    .join('|');
+
+  const quotasWithUsage: QuotaWithUsage[] = React.useMemo(
+    () =>
+      quotas
+        ?.filter((quota) =>
+          scopeDefinition.visibilityFilterFunction
+            ? scopeDefinition.visibilityFilterFunction(quota)
+            : true
+        )
+        .map((quota) => {
+          const quotaUsageQuery = usageQueryByQuotaId.get(quota.quota_id);
+          const transformedQuota = scopeDefinition.transformFunction
+            ? scopeDefinition.transformFunction(quota)
+            : quota;
+          return {
+            quota: transformedQuota,
+            hasUsage: Boolean(quotaUsageQuery),
+            usage: quotaUsageQuery?.data?.usage ?? null,
+            isFetchingUsage: quotaUsageQuery?.isFetching ?? false,
+            fetchingUsageFailed: quotaUsageQuery?.isError ?? false,
+            usageFetchErrorMessage: quotaUsageQuery?.error
+              ? quotaUsageQuery?.error[0].reason
+              : null,
+          };
+        }) ?? [],
+    [quotas, scopeDefinition, usageQueryByQuotaId, usageQueriesFingerprint]
+  );
+
+  return {
+    data: quotasWithUsage,
+    error: quotasError ? quotasError[0].reason : null,
+    isFetching: isFetchingQuotas,
+    isError: isQuotasFetchError,
+  };
+};
diff --git a/packages/manager/src/features/Account/Quotas/quotaServices.ts b/packages/manager/src/features/Account/Quotas/quotaServices.ts
new file mode 100644
index 00000000000..74a5a8829ac
--- /dev/null
+++ b/packages/manager/src/features/Account/Quotas/quotaServices.ts
@@ -0,0 +1,145 @@
+import { type Capabilities } from '@linode/api-v4';
+
+import type {
+  ObjectStorageEndpointQuota,
+  Quota,
+  QuotaServiceType,
+} from '@linode/api-v4';
+
+/**
+ * Represents the different scopes that a quota can have.
+ */
+export type QuotaScope = 'global' | 'obj-endpoint' | 'region';
+
+export interface ScopeValueSelectorProps {
+  /**
+   * An optional Capability used to filter regions applicable for the given service and scope.
+   */
+  regionCapability?: Capabilities;
+}
+
+/**
+ * Represents the definition of a quota scope, including how to retrieve and display quotas for that scope in the UI.
+ */
+export interface QuotaScopeDefinition {
+  /**
+   * The name of the API collection that corresponds to this quota scope.
+   * In most cases this will be 'quotas'.
+   */
+  apiCollection: string;
+
+  /**
+   * An optional function to provide filter for the API quota request for this scope.
+   *
+   * @param filterValue - The value to filter by, such as a region slug or Object Storage endpoint.
+   *
+   * @returns An object containing the filter parameters to apply to the API request for this quota scope.
+   */
+  apiFilterFunction?: (filterValue: string) => Partial<Quota>;
+
+  /**
+   * An optional object specifying additional props to pass to the value selector component
+   * for this quota scope, e.g. the region capabilities.
+   */
+  scopeValueSelectorProps?: ScopeValueSelectorProps;
+
+  /**
+   * An optional function to transform the quota data returned from the API for this scope before it is used in the UI.
+   *
+   * @param quota - The quota data returned from the API for this scope.
+   *
+   * @returns The transformed quota data to be used in the UI for this scope.
+   */
+  transformFunction?: (quota: Quota) => Quota;
+
+  /**
+   * An optional function to determine whether a quota should be visible in the UI for this scope.
+   *
+   * @param quota - The quota data returned from the API for this scope.
+   *
+   * @returns A boolean indicating whether the quota should be visible in the UI for this scope.
+   */
+  visibilityFilterFunction?: (quota: Quota) => boolean;
+}
+
+/**
+ * Represents a service for which quotas are defined.
+ */
+export interface QuotaService {
+  /**
+   * A user-friendly label for the service, e.g. "Linodes" or "Object Storage".
+   */
+  label: string;
+
+  /**
+   * Defines the different scopes available for this service, such as global, region, or Object Storage endpoint.
+   */
+  scopes: Partial<Record<QuotaScope, QuotaScopeDefinition>>;
+
+  /**
+   * The type of service for this quota, e.g. 'linode', 'lke' or 'object-storage'.
+   */
+  type: QuotaServiceType;
+}
+
+// TODO: not used yet - add to useQuotaServices when production-ready
+export const linodeQuotaService: QuotaService = {
+  type: 'linode',
+  label: 'Linodes',
+  scopes: {
+    region: {
+      apiCollection: 'quotas',
+      scopeValueSelectorProps: {
+        regionCapability: 'Linodes',
+      },
+      apiFilterFunction: (region: string) => ({ region_applied: region }),
+    },
+  },
+};
+
+// TODO: not used yet - add to useQuotaServices when production-ready
+export const lkeQuotaService: QuotaService = {
+  type: 'lke',
+  label: 'Kubernetes',
+  scopes: {
+    region: {
+      apiCollection: 'quotas',
+      scopeValueSelectorProps: {
+        regionCapability: 'Kubernetes',
+      },
+      apiFilterFunction: (region: string) => ({ region_applied: region }),
+    },
+  },
+};
+
+export const objectStorageQuotaService = (
+  objectStorageGlobalQuotasEnabled?: boolean
+): QuotaService =>
+  ({
+    type: 'object-storage',
+    label: 'Object Storage',
+    scopes: {
+      ...(objectStorageGlobalQuotasEnabled
+        ? ({
+            global: { apiCollection: 'global-quotas' },
+          } satisfies Partial<Record<QuotaScope, QuotaScopeDefinition>>)
+        : null),
+      'obj-endpoint': {
+        apiCollection: 'quotas',
+        apiFilterFunction: (endpoint: string) => ({ s3_endpoint: endpoint }),
+        visibilityFilterFunction: (quota: Quota) =>
+          [
+            'obj-buckets',
+            'obj-bytes',
+            'obj-objects',
+            'obj-total-concurrent-requests',
+            'obj-total-egress-throughput',
+            'obj-total-ingress-throughput',
+          ].includes((quota as ObjectStorageEndpointQuota).quota_type),
+        transformFunction: (quota: Quota) => ({
+          ...quota,
+          quota_name: quota.quota_name.replace(' (per endpoint)', ''),
+        }),
+      },
+    },
+  }) satisfies QuotaService;
diff --git a/packages/manager/src/features/Account/Quotas/utils.test.tsx b/packages/manager/src/features/Account/Quotas/utils.test.tsx
index d4ad5f3d3de..ec18bdbb5d6 100644
--- a/packages/manager/src/features/Account/Quotas/utils.test.tsx
+++ b/packages/manager/src/features/Account/Quotas/utils.test.tsx
@@ -1,21 +1,4 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
-import { profileFactory } from '@linode/utilities';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { renderHook } from '@testing-library/react';
-import * as React from 'react';
-
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
-
-import {
-  convertResourceMetric,
-  getQuotaError,
-  getQuotaIncreaseMessage,
-  pluralizeMetric,
-  useGetLocationsForQuotaService,
-} from './utils';
-
-import type { QuotaUsage } from '@linode/api-v4';
-import type { UseQueryResult } from '@tanstack/react-query';
+import { convertResourceMetric, pluralizeMetric } from './utils';
 
 const queryMocks = vi.hoisted(() => ({
   useObjectStorageEndpoints: vi.fn().mockReturnValue({}),
@@ -29,112 +12,9 @@ vi.mock('src/queries/object-storage/queries', () => {
   };
 });
 
-describe('useGetLocationsForQuotaService', () => {
-  const wrapper = ({ children }: { children: React.ReactNode }) => {
-    const queryClient = new QueryClient({
-      defaultOptions: {
-        queries: {
-          retry: false,
-        },
-      },
-    });
-
-    return (
-      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-    );
-  };
-
-  it('should handle object storage endpoints with null values', () => {
-    const { result } = renderHook(
-      () => useGetLocationsForQuotaService('object-storage'),
-      {
-        wrapper,
-      }
-    );
-
-    expect(result.current.s3Endpoints).toEqual([]);
-  });
-
-  it('should filter out endpoints with null s3_endpoint values', () => {
-    queryMocks.useObjectStorageEndpoints.mockReturnValue({
-      data: [
-        {
-          endpoint_type: 'E0',
-          s3_endpoint: 'endpoint1',
-        },
-        {
-          endpoint_type: 'E0',
-          s3_endpoint: null,
-        },
-      ],
-    });
-
-    const { result } = renderHook(
-      () => useGetLocationsForQuotaService('object-storage'),
-      {
-        wrapper,
-      }
-    );
-
-    expect(result.current.s3Endpoints).toEqual([
-      { label: 'endpoint1 (Standard E0)', value: 'endpoint1' },
-    ]);
-  });
-
-  it('should return the error for a given quota usage query', () => {
-    const quotaUsageQueries = [
-      { error: [{ reason: 'Error 1' }] },
-      { error: [{ reason: 'Error 2' }] },
-    ] as unknown as UseQueryResult<QuotaUsage, Error>[];
-    const index = 0;
-
-    const error = getQuotaError(quotaUsageQueries, index);
-
-    expect(error).toEqual('Error 1');
-  });
-
-  it('getQuotaIncreaseFormDefaultValues should return the correct default values', () => {
-    const profile = profileFactory.build();
-    const baseQuota = quotaFactory.build();
-    const quotaUsage = quotaUsageFactory.build();
-    const quota = {
-      ...baseQuota,
-      ...quotaUsage,
-    };
-    const quantity = 1;
-
-    const defaultValues = getQuotaIncreaseMessage({
-      profile,
-      quantity,
-      quota,
-      neededIn: 'Fewer than 7 days',
-      selectedService: {
-        label: 'Object Storage',
-        value: 'object-storage',
-      },
-      convertedMetrics: {
-        limit: quota.quota_limit,
-        metric: quota.resource_metric,
-      },
-    });
-
-    expect(defaultValues.description).toEqual(
-      `**User**: ${profile.username}<br>\n**Email**: ${
-        profile.email
-      }<br>\n**Quota Name**: ${
-        quota.quota_name
-      }<br>\n**Current Quota**: ${quota.quota_limit} ${
-        quota.resource_metric
-      }<br>\n**New Quota Requested**: ${quantity} ${quota.resource_metric}${
-        quantity > 1 ? 's' : ''
-      }<br>\n**Needed in**: ${defaultValues.neededIn}<br>\n**Region**: ${quota.region_applied}`
-    );
-  });
-});
-
 describe('convertResourceMetric', () => {
   it('should convert the resource metric to a human readable format', () => {
-    const resourceMetric = QuotaResourceMetrics.BYTE;
+    const resourceMetric = 'byte';
     const usage = 1e6;
     const limit = 1e8;
 
@@ -155,7 +35,7 @@ describe('convertResourceMetric', () => {
 describe('pluralizeMetric', () => {
   it('should not pluralize if the value is 1', () => {
     const value = 1;
-    const unit = QuotaResourceMetrics.CPU;
+    const unit = 'CPU';
 
     const result = pluralizeMetric(value, unit);
 
@@ -164,7 +44,7 @@ describe('pluralizeMetric', () => {
 
   it('should pluralize the resource metric if the value is greater than 1', () => {
     const value = 100;
-    const unit = QuotaResourceMetrics.CPU;
+    const unit = 'CPU';
 
     const result = pluralizeMetric(value, unit);
 
diff --git a/packages/manager/src/features/Account/Quotas/utils.ts b/packages/manager/src/features/Account/Quotas/utils.ts
index dad407d1df8..060f4c792a1 100644
--- a/packages/manager/src/features/Account/Quotas/utils.ts
+++ b/packages/manager/src/features/Account/Quotas/utils.ts
@@ -1,164 +1,22 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
-import { useRegionsQuery } from '@linode/queries';
 import { capitalize, readableBytes } from '@linode/utilities';
 import { object, string } from 'yup';
 
-import { regionSelectGlobalOption } from 'src/components/RegionSelect/constants';
-import { useObjectStorageEndpoints } from 'src/queries/object-storage/queries';
-
-import type { QuotaIncreaseFormFields } from './QuotasIncreaseForm';
+import type { QuotaIncreaseFormFields } from './QuotasPanel/QuotasIncreaseForm';
+import type { Profile, Quota } from '@linode/api-v4';
 import type {
-  Filter,
-  Profile,
-  Quota,
-  QuotaType,
-  QuotaUsage,
-  Region,
-} from '@linode/api-v4';
-import type { SelectOption } from '@linode/ui';
-import type { UseQueryResult } from '@tanstack/react-query';
-
-const INCLUDED_OBJ_QUOTA_TYPES = [
-  'obj-bytes',
-  'obj-objects',
-  'obj-buckets',
-  'obj-total-ingress-throughput',
-  'obj-total-egress-throughput',
-  'obj-total-concurrent-requests',
-];
-const INCLUDED_OBJ_GLOBAL_QUOTA_TYPES = ['keys'];
-
-export const QUOTA_ROW_MIN_HEIGHT = 58;
-
-type UseGetLocationsForQuotaService =
-  | {
-      isFetchingRegions: boolean;
-      regions: Region[];
-      s3Endpoints: null;
-      service: Exclude<QuotaType, 'object-storage'>;
-    }
-  | {
-      isFetchingS3Endpoints: boolean;
-      regions: null;
-      s3Endpoints: { label: string; value: string }[];
-      service: Extract<QuotaType, 'object-storage'>;
-    };
-
-/**
- * Function to get either:
- * - The region(s) for a given quota service (linode, lke, ...)
- * - The s3 endpoint(s) (object-storage)
- */
-export const useGetLocationsForQuotaService = (
-  service: QuotaType
-): UseGetLocationsForQuotaService => {
-  const { data: regions, isFetching: isFetchingRegions } = useRegionsQuery();
-  // In order to get the s3 endpoints, we need to query the object storage service
-  // It will only show quotas for assigned endpoints (endpoints relevant to a region a user ever created a resource in).
-  const { data: s3Endpoints, isFetching: isFetchingS3Endpoints } =
-    useObjectStorageEndpoints(service === 'object-storage');
-
-  if (service === 'object-storage') {
-    return {
-      isFetchingS3Endpoints,
-      regions: null,
-      s3Endpoints: [
-        ...(s3Endpoints ?? [])
-          .map((s3Endpoint) => {
-            if (!s3Endpoint.s3_endpoint) {
-              return null;
-            }
-
-            return {
-              label: `${s3Endpoint.s3_endpoint} (Standard ${s3Endpoint.endpoint_type})`,
-              value: s3Endpoint.s3_endpoint,
-            };
-          })
-          .filter((item) => item !== null),
-      ],
-      service: 'object-storage',
-    };
-  }
-
-  return {
-    isFetchingRegions,
-    regions: [regionSelectGlobalOption, ...(regions ?? [])],
-    s3Endpoints: null,
-    service,
-  };
-};
-
-interface GetQuotasFiltersProps {
-  location: null | SelectOption<Quota['region_applied']>;
-  service: SelectOption<QuotaType>;
-}
-
-export interface QuotaWithUsage extends Quota {
-  usage: null | QuotaUsage;
+  QuotaScope,
+  QuotaService,
+} from 'src/features/Account/Quotas/quotaServices';
+
+export interface QuotaWithUsage {
+  fetchingUsageFailed: boolean;
+  hasUsage: boolean;
+  isFetchingUsage: boolean;
+  quota: Quota;
+  usage: null | number;
+  usageFetchErrorMessage: null | string;
 }
 
-export const getQuotaVisibilityFilter = (service: QuotaType) => {
-  return {
-    isVisible(quota: Quota) {
-      if (service === 'object-storage') {
-        return (
-          INCLUDED_OBJ_QUOTA_TYPES.includes(quota.quota_type) ||
-          INCLUDED_OBJ_GLOBAL_QUOTA_TYPES.includes(quota.quota_type)
-        );
-      }
-
-      return true;
-    },
-  };
-};
-
-export const getQuotaMapper = (service: QuotaType) => {
-  return {
-    mapQuota(quota: Quota, usage: null | QuotaUsage): QuotaWithUsage {
-      if (service === 'object-storage') {
-        return {
-          ...quota,
-          quota_name: quota.quota_name.replace(' (per endpoint)', ''),
-          usage,
-        };
-      }
-
-      return {
-        ...quota,
-        usage,
-      };
-    },
-  };
-};
-
-/**
- * Function to get the filters for the quotas query
- */
-export const getQuotasFilters = ({
-  location,
-  service,
-}: GetQuotasFiltersProps): Filter => {
-  return {
-    region_applied:
-      service.value !== 'object-storage' ? location?.value : undefined,
-    s3_endpoint:
-      service.value === 'object-storage' ? location?.value : undefined,
-  };
-};
-
-/**
- * Function to get the error for a given quota usage query
- */
-export const getQuotaError = (
-  quotaUsageQueries: UseQueryResult<QuotaUsage, Error>[],
-  index: number
-) => {
-  return Array.isArray(quotaUsageQueries[index].error) &&
-    quotaUsageQueries[index].error[0]?.reason
-    ? quotaUsageQueries[index].error[0].reason
-    : 'An unexpected error occurred';
-};
-
 interface GetQuotaIncreaseFormDefaultValuesProps {
   convertedMetrics: {
     limit: number;
@@ -168,7 +26,9 @@ interface GetQuotaIncreaseFormDefaultValuesProps {
   profile: Profile | undefined;
   quantity: number;
   quota: Quota;
-  selectedService: SelectOption<QuotaType>;
+  scope: QuotaScope;
+  scopeValue: null | string;
+  service: QuotaService;
 }
 
 /**
@@ -180,50 +40,52 @@ export const getQuotaIncreaseMessage = ({
   profile,
   quantity,
   quota,
-  selectedService,
+  service,
+  scope,
+  scopeValue,
 }: GetQuotaIncreaseFormDefaultValuesProps): QuotaIncreaseFormFields => {
-  const regionAppliedLabel = quota.s3_endpoint ? 'Endpoint' : 'Region';
-  const regionAppliedValue = quota.s3_endpoint ?? quota.region_applied;
-
   if (!profile) {
     return {
       description: '',
       neededIn: 'Fewer than 7 days',
       notes: '',
       quantity: '0',
-      summary: `Increase ${selectedService.label} Quota`,
+      summary: `Increase ${service.label} Quota`,
     };
   }
 
+  let extraLine = '';
+  if (scope === 'region') {
+    extraLine = `<br>\n**Region**: ${scopeValue}`;
+  } else if (scope === 'obj-endpoint') {
+    extraLine = `<br>\n**Endpoint**: ${scopeValue}`;
+  }
+
   return {
-    description:
-      `**User**: ${profile.username}<br>\n**Email**: ${
-        profile.email
-      }<br>\n**Quota Name**: ${
-        quota.quota_name
-      }<br>\n**Current Quota**: ${convertedMetrics.limit?.toLocaleString()} ${
-        convertedMetrics.metric
-      }<br>\n**New Quota Requested**: ${quantity?.toLocaleString()} ${
-        convertedMetrics.metric
-      }<br>\n**Needed in**: ${neededIn}<br>\n` +
-      (regionAppliedValue
-        ? `**${regionAppliedLabel}**: ${regionAppliedValue}`
-        : ''),
+    description: `**User**: ${profile.username}<br>\n**Email**: ${
+      profile.email
+    }<br>\n**Quota Name**: ${
+      quota.quota_name
+    }<br>\n**Current Quota**: ${convertedMetrics.limit?.toLocaleString()} ${
+      convertedMetrics.metric
+    }<br>\n**New Quota Requested**: ${quantity?.toLocaleString()} ${
+      convertedMetrics.metric
+    }<br>\n**Needed in**: ${neededIn}${extraLine}`,
     neededIn: 'Fewer than 7 days',
     notes: '',
     quantity: String(quantity),
-    summary: `Increase ${selectedService.label} Quota`,
+    summary: `Increase ${service.label} Quota`,
   };
 };
 
 interface ConvertResourceMetricProps {
   initialLimit: number;
-  initialResourceMetric: QuotaResourceMetrics;
+  initialResourceMetric: Quota['resource_metric'];
   initialUsage: number;
 }
 
 /**
- * Function to convert the resource metric to a human readable format
+ * Function to convert the resource metric to a human-readable format
  */
 export const convertResourceMetric = ({
   initialResourceMetric,
@@ -235,7 +97,7 @@ export const convertResourceMetric = ({
   convertedUsage: number;
 } => {
   switch (initialResourceMetric) {
-    case QuotaResourceMetrics.BYTE: {
+    case 'byte': {
       const limitReadable = readableBytes(initialLimit);
 
       return {
@@ -246,7 +108,7 @@ export const convertResourceMetric = ({
         convertedResourceMetric: capitalize(limitReadable.unit),
       };
     }
-    case QuotaResourceMetrics.BYTE_PER_SECOND: {
+    case 'byte_per_second': {
       return {
         convertedUsage: 0,
         convertedResourceMetric: 'Gbps',
@@ -277,7 +139,7 @@ export const convertResourceMetric = ({
  */
 export const pluralizeMetric = (
   value: number,
-  unit: QuotaResourceMetrics
+  unit: Quota['resource_metric']
 ): string => {
   return value > 1 ? `${unit}s` : unit;
 };
diff --git a/packages/manager/src/features/ObjectStorage/QuotasInfoNotice.tsx b/packages/manager/src/features/ObjectStorage/QuotasInfoNotice.tsx
index 2d77f513cd0..28eaaadf5cc 100644
--- a/packages/manager/src/features/ObjectStorage/QuotasInfoNotice.tsx
+++ b/packages/manager/src/features/ObjectStorage/QuotasInfoNotice.tsx
@@ -13,7 +13,7 @@ export const QuotasInfoNotice = ({ action }: { action: string }) => {
     >
       <Typography fontSize="inherit">
         Did you know you can check your usage and quotas before {action}?{' '}
-        <Link to="/account/quotas">View Quotas</Link>.
+        <Link to="/quotas?service=object-storage">View Quotas</Link>.
       </Typography>
     </DismissibleBanner>
   );
diff --git a/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.test.tsx b/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.test.tsx
index dfa16bde5f8..38c080377b9 100644
--- a/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.test.tsx
+++ b/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.test.tsx
@@ -1,7 +1,9 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import * as React from 'react';
 
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import {
+  objEndpointQuotaFactory,
+  quotaUsageFactory,
+} from 'src/factories/quotas';
 import { renderWithTheme } from 'src/utilities/testHelpers';
 
 import { EndpointSummaryRow } from './EndpointSummaryRow';
@@ -38,7 +40,7 @@ vi.mock('@tanstack/react-query', async () => {
 });
 
 const quotasMock = [
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-buckets-${testEndpoint}`,
     quota_type: 'obj-buckets',
     quota_name: 'Number of Buckets',
@@ -46,9 +48,9 @@ const quotasMock = [
     s3_endpoint: testEndpoint,
     description: 'Current number of buckets per account, per endpoint',
     quota_limit: 10,
-    resource_metric: QuotaResourceMetrics.BUCKET,
+    resource_metric: 'bucket',
   }),
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-bytes-${testEndpoint}`,
     quota_type: 'obj-bytes',
     quota_name: 'Total Capacity',
@@ -56,9 +58,9 @@ const quotasMock = [
     s3_endpoint: testEndpoint,
     description: 'Current total capacity per account, per endpoint',
     quota_limit: 2048,
-    resource_metric: QuotaResourceMetrics.BYTE,
+    resource_metric: 'byte',
   }),
-  quotaFactory.build({
+  objEndpointQuotaFactory.build({
     quota_id: `obj-objects-${testEndpoint}`,
     quota_type: 'obj-objects',
     quota_name: 'Number of Objects',
@@ -66,7 +68,7 @@ const quotasMock = [
     s3_endpoint: testEndpoint,
     description: 'Current number of objects per account, per endpoint',
     quota_limit: 10,
-    resource_metric: QuotaResourceMetrics.OBJECT,
+    resource_metric: 'object',
   }),
 ];
 
@@ -83,7 +85,7 @@ const objectsUsageMock = quotaUsageFactory.build({
   usage: 5,
 });
 
-const errorMock = { error: [{ reason: 'An error occurred.' }] };
+const errorMock = [{ reason: 'An error occurred.' }];
 
 describe('EndpointSummaryRow', () => {
   it('should display usage per endpoint', async () => {
@@ -154,7 +156,7 @@ describe('EndpointSummaryRow', () => {
     ).toBeVisible();
   });
 
-  it('should display error if any usage request is failed', async () => {
+  it('should display data not available if any usage request has failed', async () => {
     queryMocks.useQueries.mockReturnValue([
       {
         isFetching: false,
@@ -176,14 +178,11 @@ describe('EndpointSummaryRow', () => {
       isFetching: false,
     });
 
-    const { findByText } = renderWithTheme(
+    const { findAllByText } = renderWithTheme(
       <EndpointSummaryRow endpoint={testEndpoint} />
     );
 
-    expect(
-      await findByText(
-        `There was an error retrieving ${testEndpoint} endpoint data.`
-      )
-    ).toBeVisible();
+    const notAvailable = await findAllByText('Data not available');
+    expect(notAvailable.length).toEqual(1);
   });
 });
diff --git a/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.tsx b/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.tsx
index 9fab92762e8..0b50b2738b8 100644
--- a/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.tsx
+++ b/packages/manager/src/features/ObjectStorage/SummaryLanding/Partials/EndpointSummaryRow.tsx
@@ -6,7 +6,11 @@ import { TableCell } from 'src/components/TableCell';
 import { TableRow } from 'src/components/TableRow';
 import { TableRowError } from 'src/components/TableRowError/TableRowError';
 import { TableRowLoading } from 'src/components/TableRowLoading/TableRowLoading';
-import { useGetQuotas } from 'src/features/Account/Quotas/hooks/useGetQuotas';
+import { useQuotasWithUsageQuery } from 'src/features/Account/Quotas/hooks/useQuotasWithUsageQuery';
+import { objectStorageQuotaService } from 'src/features/Account/Quotas/quotaServices';
+
+import type { ObjectStorageEndpointQuota } from '@linode/api-v4';
+import type { QuotaWithUsage } from 'src/features/Account/Quotas/utils';
 
 interface Props {
   endpoint: string;
@@ -14,19 +18,23 @@ interface Props {
 
 export const EndpointSummaryRow = ({ endpoint }: Props) => {
   const theme = useTheme();
+  const service = objectStorageQuotaService();
 
   const {
-    data: quotaWithUsage,
-    isFetching,
+    data: quotasWithUsage,
+    isFetching: isFetchingQuotas,
     isError,
-  } = useGetQuotas({
-    selectedLocation: endpoint,
-    selectedService: 'object-storage',
-    collectionName: 'quotas',
+  } = useQuotasWithUsageQuery({
+    service,
+    scope: 'obj-endpoint',
+    scopeValue: endpoint,
     enabled: Boolean(endpoint),
   });
 
-  if (isFetching) {
+  if (
+    isFetchingQuotas ||
+    quotasWithUsage?.some((quotaWithUsage) => quotaWithUsage.isFetchingUsage)
+  ) {
     return <TableRowLoading columns={3} />;
   }
 
@@ -39,48 +47,44 @@ export const EndpointSummaryRow = ({ endpoint }: Props) => {
     );
   }
 
-  const capacityQuota = quotaWithUsage.find(
-    (quota) => quota.quota_name === 'Total Capacity'
-  );
-  const objectsQuota = quotaWithUsage.find(
-    (quota) => quota.quota_name === 'Number of Objects'
-  );
-  const bucketsQuota = quotaWithUsage.find(
-    (quota) => quota.quota_name === 'Number of Buckets'
+  const quotasByType = quotasWithUsage.reduce(
+    (acc, quotaWithUsage) => {
+      acc[(quotaWithUsage.quota as ObjectStorageEndpointQuota).quota_type] =
+        quotaWithUsage;
+      return acc;
+    },
+    {} as Record<ObjectStorageEndpointQuota['quota_type'], QuotaWithUsage>
   );
 
+  const displayedTypes: ObjectStorageEndpointQuota['quota_type'][] = [
+    'obj-bytes',
+    'obj-objects',
+    'obj-buckets',
+  ];
+
   return (
     <TableRow>
-      {!!capacityQuota && (
-        <TableCell sx={{ paddingY: theme.spacingFunction(8) }}>
-          <Typography>{endpoint}</Typography>
-          <QuotaUsageBar
-            limit={capacityQuota.quota_limit}
-            resourceMetric={capacityQuota.resource_metric}
-            usage={capacityQuota?.usage?.usage ?? 0}
-          />
-        </TableCell>
-      )}
-      {!!objectsQuota && (
-        <TableCell sx={{ paddingY: theme.spacingFunction(8) }}>
-          <Typography>{endpoint}</Typography>
-          <QuotaUsageBar
-            limit={objectsQuota.quota_limit}
-            resourceMetric={objectsQuota.resource_metric}
-            usage={objectsQuota?.usage?.usage ?? 0}
-          />
-        </TableCell>
-      )}
-      {!!bucketsQuota && (
-        <TableCell sx={{ paddingY: theme.spacingFunction(8) }}>
-          <Typography>{endpoint}</Typography>
-          <QuotaUsageBar
-            limit={bucketsQuota.quota_limit}
-            resourceMetric={bucketsQuota.resource_metric}
-            usage={bucketsQuota?.usage?.usage ?? 0}
-          />
-        </TableCell>
-      )}
+      {displayedTypes.map((queryType) => {
+        const quotaWithUsage = quotasByType[queryType];
+        return (
+          <TableCell
+            key={queryType}
+            sx={{ paddingY: theme.spacingFunction(8) }}
+          >
+            <Typography>{endpoint}</Typography>
+
+            {!quotaWithUsage.fetchingUsageFailed ? (
+              <QuotaUsageBar
+                limit={quotaWithUsage.quota.quota_limit}
+                resourceMetric={quotaWithUsage.quota.resource_metric}
+                usage={quotaWithUsage.usage ?? 0}
+              />
+            ) : (
+              <Typography>Data not available</Typography>
+            )}
+          </TableCell>
+        );
+      })}
     </TableRow>
   );
 };
diff --git a/packages/manager/src/features/ObjectStorage/SummaryLanding/SummaryLanding.tsx b/packages/manager/src/features/ObjectStorage/SummaryLanding/SummaryLanding.tsx
index 646cfeab731..7048d6ab3f0 100644
--- a/packages/manager/src/features/ObjectStorage/SummaryLanding/SummaryLanding.tsx
+++ b/packages/manager/src/features/ObjectStorage/SummaryLanding/SummaryLanding.tsx
@@ -27,7 +27,7 @@ export const SummaryLanding = () => {
       <Typography>
         Select endpoint(s) in the dropdown to see a summary of your Global
         account. Check your usage and{' '}
-        <Link to="/account/quotas">View Quotas</Link>.
+        <Link to="/quotas?service=object-storage">View Quotas</Link>.
       </Typography>
 
       <EndpointMultiselect
diff --git a/packages/manager/src/mocks/presets/crud/handlers/quotas.ts b/packages/manager/src/mocks/presets/crud/handlers/quotas.ts
index b6d3b8510c3..ee5182cc821 100644
--- a/packages/manager/src/mocks/presets/crud/handlers/quotas.ts
+++ b/packages/manager/src/mocks/presets/crud/handlers/quotas.ts
@@ -1,9 +1,13 @@
-import { QuotaResourceMetrics } from '@linode/api-v4';
 import { pickRandom, regions } from '@linode/utilities';
 import { http } from 'msw';
 
 import { objectStorageEndpointsFactory } from 'src/factories/objectStorage';
-import { quotaFactory, quotaUsageFactory } from 'src/factories/quotas';
+import {
+  linodeQuotaFactory,
+  lkeQuotaFactory,
+  objEndpointQuotaFactory,
+  quotaUsageFactory,
+} from 'src/factories/quotas';
 import {
   makeNotFoundResponse,
   makePaginatedResponse,
@@ -13,7 +17,7 @@ import {
 import type {
   ObjectStorageEndpoint,
   Quota,
-  QuotaType,
+  QuotaServiceType,
   QuotaUsage,
 } from '@linode/api-v4';
 import type { StrictResponse } from 'msw';
@@ -22,103 +26,113 @@ import type {
   APIPaginatedResponse,
 } from 'src/mocks/utilities/response';
 
-const mockQuotas: Record<QuotaType, Quota[]> = {
+const mockQuotas: Record<QuotaServiceType, Quota[]> = {
   linode: [
     ...regions.map((region) =>
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description:
           'Max number of vCPUs assigned to Linodes with Dedicated plans',
         quota_limit: 50,
         quota_name: 'Dedicated CPU',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.CPU,
+        resource_metric: 'CPU',
       })
     ),
     ...regions.map((region) =>
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description:
           'Max number of vCPUs assigned to Linodes with Shared plans',
         quota_limit: 100,
         quota_name: 'Shared CPU',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.CPU,
+        resource_metric: 'CPU',
       })
     ),
     ...regions.map((region) =>
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description: 'Max number of GPUs assigned to Linodes with GPU plans',
         quota_limit: 25,
         quota_name: 'GPU',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.GPU,
+        resource_metric: 'GPU',
       })
     ),
     ...regions.map((region) =>
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description: 'Max number of VPUs assigned to Linodes with VPU plans',
         quota_limit: 10,
         quota_name: 'VPU',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.VPU,
+        resource_metric: 'VPU',
       })
     ),
     ...regions.map((region) =>
-      quotaFactory.build({
+      linodeQuotaFactory.build({
         description:
           'Max number of vCPUs assigned to Linodes with High Memory plans',
         quota_limit: 15,
         quota_name: 'High Memory',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.CPU,
+        resource_metric: 'CPU',
       })
     ),
   ],
   lke: [
     ...regions.map((region) =>
-      quotaFactory.build({
+      lkeQuotaFactory.build({
         quota_limit: 50,
         quota_name: 'Total number of Clusters',
         region_applied: region.id,
-        resource_metric: QuotaResourceMetrics.CLUSTER,
+        resource_metric: 'cluster',
       })
     ),
   ],
   'object-storage': [
-    quotaFactory.build({
+    objEndpointQuotaFactory.build({
       description: 'The total capacity of your Object Storage account',
       endpoint_type: 'E0',
       quota_limit: 1_000_000_000_000_000, // a petabyte
       quota_name: 'Total Capacity',
-      resource_metric: QuotaResourceMetrics.BYTE,
+      resource_metric: 'byte',
       s3_endpoint: 'us-east-1.linodeobjects.com',
     }),
-    quotaFactory.build({
+    objEndpointQuotaFactory.build({
       description:
         'The allowed number of buckets in your Object Storage account',
       endpoint_type: 'E0',
       quota_limit: 100,
       quota_name: 'Number of Buckets',
-      resource_metric: QuotaResourceMetrics.BUCKET,
+      resource_metric: 'bucket',
       s3_endpoint: 'us-west-1.linodeobjects.com',
     }),
-    quotaFactory.build({
+    objEndpointQuotaFactory.build({
       description: 'The total number of objects in your Object Storage account',
       endpoint_type: 'E3',
       quota_limit: 10_000_000,
       quota_name: 'Number of Objects',
-      resource_metric: QuotaResourceMetrics.OBJECT,
+      resource_metric: 'object',
       s3_endpoint: 'br-gru-1.linodeobjects.com',
     }),
   ],
 };
 
-const mockS3Endpoints = mockQuotas['object-storage'].map((quota) =>
+const mockS3Endpoints = [
+  objectStorageEndpointsFactory.build({
+    endpoint_type: 'E0',
+    region: 'us-east',
+    s3_endpoint: 'us-east-1.linodeobjects.com',
+  }),
   objectStorageEndpointsFactory.build({
-    endpoint_type: quota.endpoint_type,
-    region: quota.region_applied,
-    s3_endpoint: quota.s3_endpoint,
-  })
-);
+    endpoint_type: 'E0',
+    region: 'us-wast',
+    s3_endpoint: 'us-west-1.linodeobjects.com',
+  }),
+  objectStorageEndpointsFactory.build({
+    endpoint_type: 'E3',
+    region: 'br-gru',
+    s3_endpoint: 'br-gru-1.linodeobjects.com',
+  }),
+];
 
 export const getS3Endpoint = () => [
   http.get(
@@ -147,17 +161,24 @@ export const getQuotas = () => [
     }): Promise<
       StrictResponse<APIErrorResponse | APIPaginatedResponse<Quota>>
     > => {
+      let data = mockQuotas[params.service as QuotaServiceType];
+      if (!data) {
+        return makeNotFoundResponse();
+      }
+
       const xFilters = request.headers.get('X-Filter');
-      const filters = xFilters ? JSON.parse(xFilters) : {};
+      const filters: Record<string, any> = xFilters ? JSON.parse(xFilters) : {};
+      const filterKeys = Object.keys(filters);
 
-      // if we got a global filter, do a randomized sorting on the data,
-      // otherwise, return the data as is
-      const data =
-        filters.region_applied || filters.s3_endpoint === 'global'
-          ? mockQuotas[params.service as QuotaType].sort(
-              () => Math.random() - 0.5
-            )
-          : mockQuotas[params.service as QuotaType];
+      if (filterKeys.length > 0) {
+        data = data.filter((quota) =>
+          filterKeys.every((key) => {
+            const filterVal = filters[key];
+            const quotaVal = (quota as Record<string, any>)[key];
+            return filterVal === quotaVal;
+          })
+        );
+      }
 
       return makePaginatedResponse({
         data,
@@ -169,7 +190,7 @@ export const getQuotas = () => [
   http.get(
     '*/v4*/:service/quotas/:id',
     async ({ params }): Promise<StrictResponse<APIErrorResponse | Quota>> => {
-      const quota = mockQuotas[params.service as QuotaType].find(
+      const quota = mockQuotas[params.service as QuotaServiceType].find(
         ({ quota_id }) => quota_id === params.id
       );
 
@@ -186,7 +207,7 @@ export const getQuotas = () => [
     async ({
       params,
     }): Promise<StrictResponse<APIErrorResponse | QuotaUsage>> => {
-      const service = params.service as QuotaType;
+      const service = params.service as QuotaServiceType;
       const quota = mockQuotas[service].find(
         ({ quota_id }) => quota_id === params.id
       );
diff --git a/packages/manager/src/mocks/serverHandlers.ts b/packages/manager/src/mocks/serverHandlers.ts
index dd7c919570b..c2bdb1c9a2f 100644
--- a/packages/manager/src/mocks/serverHandlers.ts
+++ b/packages/manager/src/mocks/serverHandlers.ts
@@ -141,7 +141,7 @@ import { accountAgreementsFactory } from 'src/factories/accountAgreements';
 import { accountLoginFactory } from 'src/factories/accountLogin';
 import { accountUserFactory } from 'src/factories/accountUsers';
 import { LinodeKernelFactory } from 'src/factories/linodeKernel';
-import { quotaFactory } from 'src/factories/quotas';
+import { objEndpointQuotaFactory } from 'src/factories/quotas';
 import { getStorage } from 'src/utilities/storage';
 
 import type { PathParams } from 'msw';
@@ -149,8 +149,6 @@ import type { PathParams } from 'msw';
 const getRandomWholeNumber = (min: number, max: number) =>
   Math.floor(Math.random() * (max - min + 1) + min);
 
-import { QuotaResourceMetrics } from '@linode/api-v4';
-
 import { accountEntityFactory } from 'src/factories/accountEntities';
 import { accountRolesFactory } from 'src/factories/accountRoles';
 import { trustedDeviceFactory } from 'src/factories/devices';
@@ -1845,13 +1843,12 @@ export const handlers = [
   }),
   http.get('*/v4*/object-storage/quotas*', () => {
     const quotas = [
-      quotaFactory.build({
+      objEndpointQuotaFactory.build({
         description: 'The total capacity of your Object Storage account',
         endpoint_type: 'E0',
         quota_limit: 1_000_000_000_000_000,
         quota_name: 'Total Capacity',
-        resource_metric: QuotaResourceMetrics.BYTE,
-        s3_endpoint: 'endpoint1',
+        resource_metric: 'byte',
       }),
     ];
 
diff --git a/packages/manager/src/routes/quotas/index.ts b/packages/manager/src/routes/quotas/index.ts
index 12567a1b236..c7e037a0d0e 100644
--- a/packages/manager/src/routes/quotas/index.ts
+++ b/packages/manager/src/routes/quotas/index.ts
@@ -3,10 +3,17 @@ import { createRoute, redirect } from '@tanstack/react-router';
 import { rootRoute } from '../root';
 import { QuotasRoute } from './QuotasRoute';
 
+import type { QuotaServiceType } from '@linode/api-v4';
+
+interface QuotasSearchParams {
+  service?: QuotaServiceType;
+}
+
 const quotasRoute = createRoute({
   component: QuotasRoute,
   getParentRoute: () => rootRoute,
   path: 'quotas',
+  validateSearch: (search: QuotasSearchParams) => search,
 });
 
 // Catch all route for quotas page
diff --git a/packages/queries/src/quotas/keys.ts b/packages/queries/src/quotas/keys.ts
index 077871cfee2..2c2484fa724 100644
--- a/packages/queries/src/quotas/keys.ts
+++ b/packages/queries/src/quotas/keys.ts
@@ -3,28 +3,28 @@ import { createQueryKeys } from '@lukemorales/query-key-factory';
 
 import { getAllQuotas } from './requests';
 
-import type { Filter, Params, QuotaType } from '@linode/api-v4';
+import type { Filter, Params, QuotaServiceType } from '@linode/api-v4';
 
 export const quotaQueries = createQueryKeys('quotas', {
-  service: (type: QuotaType, collection: string) => ({
+  serviceQuotas: (serviceType: QuotaServiceType, apiCollection: string) => ({
     contextQueries: {
       all: (params: Params = {}, filter: Filter = {}) => ({
-        queryFn: () => getAllQuotas(type, collection, params, filter),
-        queryKey: [params, filter, collection],
+        queryFn: () => getAllQuotas(serviceType, apiCollection, params, filter),
+        queryKey: [params, filter, apiCollection],
       }),
       paginated: (params: Params = {}, filter: Filter = {}) => ({
-        queryFn: () => getQuotas(type, collection, params, filter),
-        queryKey: [params, filter, collection],
+        queryFn: () => getQuotas(serviceType, apiCollection, params, filter),
+        queryKey: [params, filter, apiCollection],
       }),
       quota: (id: number) => ({
-        queryFn: () => getQuota(type, collection, id),
-        queryKey: [id, collection],
+        queryFn: () => getQuota(serviceType, apiCollection, id),
+        queryKey: [id, apiCollection],
       }),
       usage: (id: string) => ({
-        queryFn: () => getQuotaUsage(type, collection, id),
-        queryKey: [id, collection],
+        queryFn: () => getQuotaUsage(serviceType, apiCollection, id),
+        queryKey: [id, apiCollection],
       }),
     },
-    queryKey: [type],
+    queryKey: [serviceType],
   }),
 });
diff --git a/packages/queries/src/quotas/quotas.ts b/packages/queries/src/quotas/quotas.ts
index e5e1d3bcd91..5d1e1b55057 100644
--- a/packages/queries/src/quotas/quotas.ts
+++ b/packages/queries/src/quotas/quotas.ts
@@ -1,61 +1,42 @@
-import { keepPreviousData, useQuery } from '@tanstack/react-query';
+import { useQuery } from '@tanstack/react-query';
 
+import { useQueries } from '../index';
 import { quotaQueries } from './keys';
 
 import type {
   APIError,
   Filter,
-  Params,
   Quota,
-  QuotaType,
+  QuotaServiceType,
   QuotaUsage,
-  ResourcePage,
 } from '@linode/api-v4';
-
-export const useQuotaQuery = (
-  service: QuotaType,
-  collection: string,
-  id: number,
-  enabled = true,
-) =>
-  useQuery<Quota, APIError[]>({
-    ...quotaQueries.service(service, collection)._ctx.quota(id),
-    enabled,
-  });
-
-export const useQuotasQuery = (
-  service: QuotaType,
-  collection: string,
-  params: Params = {},
-  filter: Filter,
-  enabled = true,
-) => {
-  return useQuery<ResourcePage<Quota>, APIError[]>({
-    ...quotaQueries.service(service, collection)._ctx.paginated(params, filter),
-    enabled,
-    placeholderData: keepPreviousData,
-  });
-};
+import type { UseQueryResult } from '@tanstack/react-query';
 
 export const useAllQuotasQuery = (
-  service: QuotaType,
-  collection: string,
-  params: Params = {},
-  filter: Filter,
+  serviceType: QuotaServiceType,
+  apiCollection: string,
+  filter: Filter = {},
   enabled = true,
-) =>
+): UseQueryResult<Quota[], APIError[]> =>
   useQuery<Quota[], APIError[]>({
-    ...quotaQueries.service(service, collection)._ctx.all(params, filter),
+    ...quotaQueries
+      .serviceQuotas(serviceType, apiCollection)
+      ._ctx.all({}, filter),
     enabled,
   });
 
-export const useQuotaUsageQuery = (
-  service: QuotaType,
-  collection: string,
-  id: string,
+export const useQuotaUsageQueries = (
+  serviceType: QuotaServiceType,
+  apiCollection: string,
+  quotaIds: string[],
   enabled = true,
-) =>
-  useQuery<QuotaUsage, APIError[]>({
-    ...quotaQueries.service(service, collection)._ctx.usage(id),
-    enabled,
+): UseQueryResult<QuotaUsage, APIError[]>[] =>
+  useQueries({
+    queries: quotaIds.map(
+      (quotaId) =>
+        quotaQueries
+          .serviceQuotas(serviceType, apiCollection)
+          ._ctx.usage(quotaId),
+      enabled,
+    ),
   });
diff --git a/packages/queries/src/quotas/requests.ts b/packages/queries/src/quotas/requests.ts
index 50a9056b32a..659389b1ba8 100644
--- a/packages/queries/src/quotas/requests.ts
+++ b/packages/queries/src/quotas/requests.ts
@@ -1,18 +1,18 @@
 import { getQuotas } from '@linode/api-v4';
 import { getAll } from '@linode/utilities';
 
-import type { Filter, Params, Quota, QuotaType } from '@linode/api-v4';
+import type { Filter, Params, Quota, QuotaServiceType } from '@linode/api-v4';
 
 export const getAllQuotas = (
-  service: QuotaType,
-  collection: string,
+  service: QuotaServiceType,
+  apiCollection: string,
   passedParams: Params = {},
   passedFilter: Filter = {},
 ) =>
   getAll<Quota>((params, filter) =>
     getQuotas(
       service,
-      collection,
+      apiCollection,
       { ...params, ...passedParams },
       { ...filter, ...passedFilter },
     ),