diff --git a/packages/core/src/app/address/AddressForm.tsx b/packages/core/src/app/address/AddressForm.tsx
index 08d123e454..d12f3220f5 100644
--- a/packages/core/src/app/address/AddressForm.tsx
+++ b/packages/core/src/app/address/AddressForm.tsx
@@ -58,6 +58,11 @@ const AddressForm: React.FC<AddressFormProps> = ({
         'CHECKOUT-9019.use_new_phone_number_validation',
         false,
     );
+    const isNewGooglePlacesApiEnabled = isExperimentEnabled(
+        config?.checkoutSettings,
+        'CHECKOUT-10026.new_google_places_api',
+        false,
+    );
     const countriesWithAutocomplete = ['US', 'CA', 'AU', 'NZ', 'GB'];
 
     const containerRef = useRef<HTMLDivElement>(null);
@@ -171,6 +176,7 @@ const AddressForm: React.FC<AddressFormProps> = ({
                                     countryCode={countryCode}
                                     field={field}
                                     isFloatingLabelEnabled={isFloatingLabelEnabledValue}
+                                    isNewPlacesApiEnabled={isNewGooglePlacesApiEnabled}
                                     key={field.id}
                                     nextElement={nextElementRef.current || undefined}
                                     onChange={handleAutocompleteChange}
diff --git a/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.test.tsx b/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.test.tsx
new file mode 100644
index 0000000000..a3ac42a030
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.test.tsx
@@ -0,0 +1,260 @@
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+
+import { render, screen, waitFor } from '@bigcommerce/checkout/test-utils';
+
+import GoogleAutocomplete, {
+    type GoogleAutocompleteProps,
+    newGooglePlacesApiState,
+} from './GoogleAutocomplete';
+import LegacyGoogleAutocompleteService from './GoogleAutocompleteService';
+import { NewGooglePlacesApiService } from './newGooglePlacesApi/NewGooglePlacesApiService';
+
+jest.mock('./GoogleAutocompleteService');
+jest.mock('./newGooglePlacesApi/NewGooglePlacesApiService');
+
+const MockLegacyService = LegacyGoogleAutocompleteService as jest.MockedClass<
+    typeof LegacyGoogleAutocompleteService
+>;
+const MockPlacesApiService = NewGooglePlacesApiService as jest.MockedClass<
+    typeof NewGooglePlacesApiService
+>;
+
+const legacySuggestions = [
+    {
+        description: '123 Legacy St, New York',
+        structured_formatting: { main_text: '123 Legacy St' },
+        matched_substrings: [],
+        place_id: 'legacy-place-1',
+    },
+];
+
+const legacyPlaceResult = {
+    name: '123 Legacy St',
+    address_components: [],
+} as google.maps.places.PlaceResult;
+
+const newApiSuggestions = [
+    { id: 'new-place-1', label: '123 New API Ave', value: '123 New API Ave' },
+];
+
+const newApiPlaceResult = {
+    name: '123 New API Ave',
+    address_components: [],
+} as google.maps.places.PlaceResult;
+
+const gRpcPermissionDeniedErrorMock = { name: 'RpcError', code: 7 };
+const gRpcSomeOtherErrorMock = { name: 'RpcError', code: 14 };
+
+describe('GoogleAutocomplete', () => {
+    let mockGetPlacePredictions: jest.Mock;
+    let mockGetDetails: jest.Mock;
+    let mockGetSuggestions: jest.Mock;
+    let mockGetPlaceDetails: jest.Mock;
+    let defaultProps: GoogleAutocompleteProps;
+
+    beforeEach(() => {
+        newGooglePlacesApiState.isUnavailable = false;
+
+        mockGetPlacePredictions = jest.fn();
+        mockGetDetails = jest.fn();
+        mockGetSuggestions = jest.fn().mockResolvedValue(newApiSuggestions);
+        mockGetPlaceDetails = jest.fn().mockResolvedValue(newApiPlaceResult);
+
+        MockLegacyService.mockImplementation(
+            () =>
+                ({
+                    getAutocompleteService: jest
+                        .fn()
+                        .mockResolvedValue({ getPlacePredictions: mockGetPlacePredictions }),
+                    getPlacesServices: jest.fn().mockResolvedValue({ getDetails: mockGetDetails }),
+                }) as unknown as LegacyGoogleAutocompleteService,
+        );
+
+        MockPlacesApiService.mockImplementation(
+            () =>
+                ({
+                    getSuggestions: mockGetSuggestions,
+                    getPlaceDetails: mockGetPlaceDetails,
+                }) as unknown as NewGooglePlacesApiService,
+        );
+
+        defaultProps = {
+            apiKey: 'test-api-key',
+            isAutocompleteEnabled: true,
+            isNewPlacesApiEnabled: true,
+            onSelect: jest.fn(),
+            onChange: jest.fn(),
+        };
+    });
+
+    describe('new API available (preferred path)', () => {
+        it('shows suggestions from the new API', async () => {
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+
+            await screen.findByText('123 New API Ave');
+            expect(mockGetPlacePredictions).not.toHaveBeenCalled();
+        });
+
+        it('debounces rapid keystrokes into a single new API request', async () => {
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+
+            await screen.findByText('123 New API Ave');
+
+            // Three characters, one request — for the full final value.
+            expect(mockGetSuggestions).toHaveBeenCalledTimes(1);
+            expect(mockGetSuggestions).toHaveBeenCalledWith('123', undefined, undefined);
+        });
+
+        it('calls onSelect with the new API place result when a suggestion is picked', async () => {
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+            await screen.findByText('123 New API Ave');
+            await userEvent.click(screen.getByText('123 New API Ave'));
+
+            await waitFor(() =>
+                expect(defaultProps.onSelect).toHaveBeenCalledWith(
+                    newApiPlaceResult,
+                    expect.objectContaining({ id: 'new-place-1' }),
+                ),
+            );
+            expect(mockGetDetails).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('new API unavailable (fall back to legacy)', () => {
+        beforeEach(() => {
+            mockGetPlacePredictions.mockImplementation((_req, cb) => cb(legacySuggestions, 'OK'));
+            mockGetDetails.mockImplementation((_req, cb) => cb(legacyPlaceResult, 'OK'));
+        });
+
+        it('falls back to the legacy service for suggestions when the new API is denied', async () => {
+            mockGetSuggestions.mockRejectedValue(gRpcPermissionDeniedErrorMock);
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+
+            await screen.findByText('123 Legacy St, New York');
+            expect(mockGetPlacePredictions).toHaveBeenCalled();
+        });
+
+        it('does not fall back to legacy for a non-permission suggestions failure', async () => {
+            mockGetSuggestions.mockRejectedValue(gRpcSomeOtherErrorMock);
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+
+            await waitFor(() => expect(mockGetSuggestions).toHaveBeenCalled());
+            expect(screen.queryByText('123 Legacy St, New York')).not.toBeInTheDocument();
+            expect(mockGetPlacePredictions).not.toHaveBeenCalled();
+        });
+
+        it('latches onto legacy after a permission denial and stops retrying the new API', async () => {
+            mockGetSuggestions.mockRejectedValue(gRpcPermissionDeniedErrorMock);
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            const input = screen.getByRole('textbox');
+
+            // First debounced request hits the new API, is denied, and latches the fallback flag.
+            await userEvent.type(input, '1');
+            await screen.findByText('123 Legacy St, New York');
+            expect(mockGetSuggestions).toHaveBeenCalledTimes(1);
+
+            // A later request goes straight to legacy without retrying the new API.
+            await userEvent.type(input, '2');
+            await waitFor(() => expect(mockGetPlacePredictions).toHaveBeenCalledTimes(2));
+            expect(mockGetSuggestions).toHaveBeenCalledTimes(1);
+        });
+
+        it('keeps retrying the new API on later input after a transient failure, without falling back', async () => {
+            mockGetSuggestions.mockRejectedValue(gRpcSomeOtherErrorMock);
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            const input = screen.getByRole('textbox');
+
+            // First request fails transiently; no fallback and no latch, since it's not a permission denial.
+            await userEvent.type(input, '1');
+            await waitFor(() => expect(mockGetSuggestions).toHaveBeenCalledTimes(1));
+            expect(mockGetPlacePredictions).not.toHaveBeenCalled();
+
+            // The new API is tried again on the next input, since the failure was not permanent.
+            await userEvent.type(input, '2');
+            await waitFor(() => expect(mockGetSuggestions).toHaveBeenCalledTimes(2));
+        });
+
+        it('falls back to the legacy service for place details when the new API denies permission', async () => {
+            // Suggestions still come from the new API so the dropdown has an item to click,
+            // but getPlaceDetails is denied, forcing the legacy getDetails fallback.
+            mockGetPlaceDetails.mockRejectedValue(gRpcPermissionDeniedErrorMock);
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '1');
+            await screen.findByText('123 New API Ave');
+            await userEvent.click(screen.getByText('123 New API Ave'));
+
+            await waitFor(() =>
+                expect(defaultProps.onSelect).toHaveBeenCalledWith(
+                    legacyPlaceResult,
+                    expect.objectContaining({ id: 'new-place-1' }),
+                ),
+            );
+            expect(mockGetDetails).toHaveBeenCalled();
+        });
+
+        it('does not fall back to legacy for a non-permission place details failure', async () => {
+            mockGetPlaceDetails.mockRejectedValue(new Error('new API down'));
+
+            render(<GoogleAutocomplete {...defaultProps} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '1');
+            await screen.findByText('123 New API Ave');
+            await userEvent.click(screen.getByText('123 New API Ave'));
+
+            await waitFor(() => expect(mockGetPlaceDetails).toHaveBeenCalled());
+            expect(mockGetDetails).not.toHaveBeenCalled();
+            expect(defaultProps.onSelect).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('new API disabled via experiment flag', () => {
+        beforeEach(() => {
+            mockGetPlacePredictions.mockImplementation((_req, cb) => cb(legacySuggestions, 'OK'));
+            mockGetDetails.mockImplementation((_req, cb) => cb(legacyPlaceResult, 'OK'));
+        });
+
+        it('goes straight to the legacy service for suggestions without calling the new API', async () => {
+            render(<GoogleAutocomplete {...defaultProps} isNewPlacesApiEnabled={false} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '123');
+
+            await screen.findByText('123 Legacy St, New York');
+            expect(mockGetSuggestions).not.toHaveBeenCalled();
+        });
+
+        it('goes straight to the legacy service for place details without calling the new API', async () => {
+            render(<GoogleAutocomplete {...defaultProps} isNewPlacesApiEnabled={false} />);
+
+            await userEvent.type(screen.getByRole('textbox'), '1');
+            await screen.findByText('123 Legacy St, New York');
+            await userEvent.click(screen.getByText('123 Legacy St, New York'));
+
+            await waitFor(() =>
+                expect(defaultProps.onSelect).toHaveBeenCalledWith(
+                    legacyPlaceResult,
+                    expect.objectContaining({ id: 'legacy-place-1' }),
+                ),
+            );
+            expect(mockGetPlaceDetails).not.toHaveBeenCalled();
+        });
+    });
+});
diff --git a/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.tsx b/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.tsx
index ebc4c45343..19e998a9cc 100644
--- a/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.tsx
+++ b/packages/core/src/app/address/googleAutocomplete/GoogleAutocomplete.tsx
@@ -1,10 +1,12 @@
-import { noop } from 'lodash';
-import React, { useRef, useState } from 'react';
+import { debounce, noop } from 'lodash';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
 
 import { Autocomplete, type AutocompleteItem } from '@bigcommerce/checkout/ui';
 
 import GoogleAutocompleteService from './GoogleAutocompleteService';
 import { type GoogleAutocompleteOptionTypes } from './googleAutocompleteTypes';
+import { getNewGooglePlacesApiScriptLoader, NewGooglePlacesApiService } from './newGooglePlacesApi';
+import { isNewPlacesApiPermissionDenied } from './newGooglePlacesApi/utils';
 import './GoogleAutocomplete.scss';
 
 export interface GoogleAutocompleteProps {
@@ -15,6 +17,7 @@ export interface GoogleAutocompleteProps {
     nextElement?: HTMLElement;
     inputProps?: any;
     isAutocompleteEnabled?: boolean;
+    isNewPlacesApiEnabled?: boolean;
     types?: GoogleAutocompleteOptionTypes[];
     onSelect?(place: google.maps.places.PlaceResult, item: AutocompleteItem): void;
     onToggleOpen?(state: { inputValue: string; isOpen: boolean }): void;
@@ -32,6 +35,10 @@ const toAutocompleteItems = (
     }));
 };
 
+export const newGooglePlacesApiState = { isUnavailable: false };
+
+const SUGGESTIONS_DEBOUNCE_MS = 300;
+
 const GoogleAutocomplete: React.FC<GoogleAutocompleteProps> = ({
     initialValue,
     onToggleOpen = noop,
@@ -40,6 +47,7 @@ const GoogleAutocomplete: React.FC<GoogleAutocompleteProps> = ({
     onSelect = noop,
     nextElement,
     isAutocompleteEnabled,
+    isNewPlacesApiEnabled = false,
     onChange = noop,
     componentRestrictions,
     types,
@@ -47,32 +55,95 @@ const GoogleAutocomplete: React.FC<GoogleAutocompleteProps> = ({
 }) => {
     const [items, setItems] = useState<AutocompleteItem[]>([]);
     const [autoComplete, setAutoComplete] = useState<string>('off');
+    const newGooglePlacesApiServiceRef = useRef<NewGooglePlacesApiService>();
     const googleAutocompleteServiceRef = useRef<GoogleAutocompleteService>();
 
+    if (!newGooglePlacesApiServiceRef.current) {
+        newGooglePlacesApiServiceRef.current = new NewGooglePlacesApiService(apiKey);
+    }
+
     if (!googleAutocompleteServiceRef.current) {
-        googleAutocompleteServiceRef.current = new GoogleAutocompleteService(apiKey);
+        // When the new Places API is enabled, the legacy service must share the same
+        // script-loader instance as NewGooglePlacesApiService (rather than loading the Maps
+        // JS API a second time via the old loader), so its permission-denied fallback stays
+        // reliable for stores whose API key doesn't yet support the new Places API.
+        googleAutocompleteServiceRef.current = new GoogleAutocompleteService(
+            apiKey,
+            isNewPlacesApiEnabled ? getNewGooglePlacesApiScriptLoader() : undefined,
+        );
     }
 
+    const finalizeSelection = (
+        place: google.maps.places.PlaceResult | null,
+        item: AutocompleteItem,
+    ) => {
+        if (nextElement) {
+            nextElement.focus();
+        }
+
+        onSelect(place, item);
+    };
+
+    const handleFetchLegacySuggestions = (input: string): void => {
+        googleAutocompleteServiceRef
+            .current!.getAutocompleteService()
+            .then((autocompleteService) => {
+                autocompleteService.getPlacePredictions(
+                    { input, types: types || ['geocode'], componentRestrictions },
+                    (results) => {
+                        setItems(toAutocompleteItems(results ?? undefined));
+                    },
+                );
+            })
+            .catch(noop);
+    };
+
+    const handleFetchNewApiSuggestions = (input: string): void => {
+        newGooglePlacesApiServiceRef
+            .current!.getSuggestions(input, types, componentRestrictions)
+            .then(setItems)
+            .catch((error) => {
+                if (isNewPlacesApiPermissionDenied(error)) {
+                    newGooglePlacesApiState.isUnavailable = true;
+                    handleFetchLegacySuggestions(input);
+                }
+            });
+    };
+
+    const handleSelectViaLegacy = (item: AutocompleteItem): void => {
+        googleAutocompleteServiceRef
+            .current!.getPlacesServices()
+            .then((placesService) => {
+                placesService.getDetails(
+                    { placeId: item.id, fields: fields || ['address_components', 'name'] },
+                    (result) => {
+                        finalizeSelection(result, item);
+                    },
+                );
+            })
+            .catch(noop);
+    };
+
+    const handleSelectViaNewApi = (item: AutocompleteItem): void => {
+        newGooglePlacesApiServiceRef
+            .current!.getPlaceDetails(item.id, fields)
+            .then((result) => finalizeSelection(result, item))
+            .catch((error) => {
+                if (isNewPlacesApiPermissionDenied(error)) {
+                    newGooglePlacesApiState.isUnavailable = true;
+                    handleSelectViaLegacy(item);
+                }
+            });
+    };
+
     const onSelectHandler = (item: AutocompleteItem) => {
-        const service = googleAutocompleteServiceRef.current;
-
-        if (!service) return;
-
-        service.getPlacesServices().then((placesService) => {
-            placesService.getDetails(
-                {
-                    placeId: item.id,
-                    fields: fields || ['address_components', 'name'],
-                },
-                (result) => {
-                    if (nextElement) {
-                        nextElement.focus();
-                    }
-
-                    onSelect(result, item);
-                },
-            );
-        });
+        if (!isNewPlacesApiEnabled || newGooglePlacesApiState.isUnavailable) {
+            handleSelectViaLegacy(item);
+
+            return;
+        }
+
+        handleSelectViaNewApi(item);
     };
 
     const resetAutocomplete = (): void => {
@@ -84,42 +155,53 @@ const GoogleAutocomplete: React.FC<GoogleAutocompleteProps> = ({
         setAutoComplete(input && input.length ? 'nope' : 'off');
     };
 
-    const setItemsFromInput = (input: string): void => {
-        if (!input) {
-            setItems([]);
+    const fetchSuggestions = (input: string): void => {
+        if (!isNewPlacesApiEnabled || newGooglePlacesApiState.isUnavailable) {
+            handleFetchLegacySuggestions(input);
 
             return;
         }
 
-        const service = googleAutocompleteServiceRef.current;
+        handleFetchNewApiSuggestions(input);
+    };
 
-        if (!service) return;
+    const fetchSuggestionsRef = useRef(fetchSuggestions);
 
-        service.getAutocompleteService().then((autocompleteService) => {
-            autocompleteService.getPlacePredictions(
-                {
-                    input,
-                    types: types || ['geocode'],
-                    componentRestrictions,
-                },
-                (results) => {
-                    const autocompleteItems = toAutocompleteItems(results ?? undefined);
+    fetchSuggestionsRef.current = fetchSuggestions;
 
-                    setItems(autocompleteItems);
-                },
-            );
-        });
-    };
+    // using ref to make sure the function is always up to date
+    const debouncedFetchSuggestions = useMemo(
+        () =>
+            debounce(
+                (input: string) => fetchSuggestionsRef.current(input),
+                SUGGESTIONS_DEBOUNCE_MS,
+            ),
+        [],
+    );
+
+    // cleanup debounce on component unmount
+    useEffect(() => () => debouncedFetchSuggestions.cancel(), [debouncedFetchSuggestions]);
 
     const onChangeHandler = (input: string) => {
         onChange(input, false);
 
         if (!isAutocompleteEnabled) {
+            debouncedFetchSuggestions.cancel();
+
             return resetAutocomplete();
         }
 
         setAutocompleteValue(input);
-        setItemsFromInput(input);
+
+        // Clearing the field should empty the list immediately, not after the debounce.
+        if (!input) {
+            debouncedFetchSuggestions.cancel();
+            setItems([]);
+
+            return;
+        }
+
+        debouncedFetchSuggestions(input);
     };
 
     return (
diff --git a/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteFormField.tsx b/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteFormField.tsx
index 2fec8edc00..3bceeaa78e 100644
--- a/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteFormField.tsx
+++ b/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteFormField.tsx
@@ -21,6 +21,7 @@ export interface GoogleAutocompleteFormFieldProps {
     nextElement?: HTMLElement;
     parentFieldName?: string;
     isFloatingLabelEnabled?: boolean;
+    isNewPlacesApiEnabled?: boolean;
     onSelect(place: google.maps.places.PlaceResult, item: AutocompleteItem): void;
     onToggleOpen?(state: { inputValue: string; isOpen: boolean }): void;
     onChange(value: string, isOpen: boolean): void;
@@ -37,6 +38,7 @@ const GoogleAutocompleteFormField: FunctionComponent<GoogleAutocompleteFormField
     onChange,
     onToggleOpen,
     isFloatingLabelEnabled,
+    isNewPlacesApiEnabled,
 }) => {
     const fieldName = parentFieldName ? `${parentFieldName}.${name}` : name;
 
@@ -68,6 +70,7 @@ const GoogleAutocompleteFormField: FunctionComponent<GoogleAutocompleteFormField
                 isAutocompleteEnabled={
                     countryCode ? supportedCountries.includes(countryCode) : false
                 }
+                isNewPlacesApiEnabled={isNewPlacesApiEnabled}
                 nextElement={nextElement}
                 onChange={onChange}
                 onSelect={onSelect}
@@ -78,6 +81,7 @@ const GoogleAutocompleteFormField: FunctionComponent<GoogleAutocompleteFormField
             apiKey,
             countryCode,
             inputProps,
+            isNewPlacesApiEnabled,
             nextElement,
             onChange,
             onSelect,
diff --git a/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteService.ts b/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteService.ts
index ae5ce4840a..ada11dc6de 100644
--- a/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteService.ts
+++ b/packages/core/src/app/address/googleAutocomplete/GoogleAutocompleteService.ts
@@ -1,5 +1,5 @@
 import getGoogleAutocompleteScriptLoader from './getGoogleAutocompleteScriptLoader';
-import type GoogleAutocompleteScriptLoader from './GoogleAutocompleteScriptLoader';
+import { type GoogleMapsPlacesScriptLoader } from './googleAutocompleteTypes';
 
 export default class GoogleAutocompleteService {
     private _autocompletePromise?: Promise<google.maps.places.AutocompleteService>;
@@ -7,7 +7,7 @@ export default class GoogleAutocompleteService {
 
     constructor(
         private _apiKey: string,
-        private _scriptLoader: GoogleAutocompleteScriptLoader = getGoogleAutocompleteScriptLoader(),
+        private _scriptLoader: GoogleMapsPlacesScriptLoader = getGoogleAutocompleteScriptLoader(),
     ) {}
 
     getAutocompleteService(): Promise<google.maps.places.AutocompleteService> {
diff --git a/packages/core/src/app/address/googleAutocomplete/googleAutocompleteTypes.ts b/packages/core/src/app/address/googleAutocomplete/googleAutocompleteTypes.ts
index d78c8f72d3..0abba0912a 100644
--- a/packages/core/src/app/address/googleAutocomplete/googleAutocompleteTypes.ts
+++ b/packages/core/src/app/address/googleAutocomplete/googleAutocompleteTypes.ts
@@ -39,6 +39,13 @@ export interface GoogleAutocompleteWindow extends Window {
     };
 }
 
+// Satisfied by both GoogleAutocompleteScriptLoader (legacy `@bigcommerce/script-loader` path)
+// and NewGooglePlacesApiScriptLoader's adapter (importLibrary path), so
+// GoogleAutocompleteService can be handed either one without depending on its concrete type.
+export interface GoogleMapsPlacesScriptLoader {
+    loadMapsSdk(apiKey: string): Promise<GoogleMapsSdk>;
+}
+
 export type GoogleAddressFieldType =
     | 'postal_town'
     | 'administrative_area_level_1'
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.test.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.test.ts
new file mode 100644
index 0000000000..37cd89a16e
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.test.ts
@@ -0,0 +1,109 @@
+import { NewGooglePlacesApiScriptLoader } from './NewGooglePlacesApiScriptLoader';
+
+type MutableWindow = Record<string, any>;
+
+describe('NewGooglePlacesApiScriptLoader', () => {
+    const placesLibrary = {
+        AutocompleteSuggestion: {},
+        AutocompleteSessionToken: {},
+        Place: {},
+        AutocompleteService: {},
+        PlacesService: {},
+    };
+
+    afterEach(() => {
+        // this only removes the google property for test isolation
+        delete (window as MutableWindow).google;
+        document.head
+            .querySelectorAll('script[src*="maps.googleapis.com"]')
+            .forEach((node) => node.remove());
+    });
+
+    describe('when importLibrary is already available', () => {
+        let importLibrary: jest.Mock;
+
+        beforeEach(() => {
+            importLibrary = jest.fn().mockResolvedValue(placesLibrary);
+            (window as MutableWindow).google = { maps: { importLibrary } };
+        });
+
+        it('loads the places library via the existing importLibrary without bootstrapping', async () => {
+            const loader = new NewGooglePlacesApiScriptLoader();
+
+            const library = await loader.loadPlacesLibrary('foo');
+
+            expect(importLibrary).toHaveBeenCalledWith('places');
+            expect(library).toBe(placesLibrary);
+            expect(document.head.querySelector('script[src*="maps.googleapis.com"]')).toBeNull();
+        });
+
+        it('memoizes the library so importLibrary is only called once', async () => {
+            const loader = new NewGooglePlacesApiScriptLoader();
+
+            await loader.loadPlacesLibrary('foo');
+            await loader.loadPlacesLibrary('foo');
+            await loader.loadPlacesLibrary('foo');
+
+            expect(importLibrary).toHaveBeenCalledTimes(1);
+        });
+
+        it('clears the cached promise on failure so a later call can retry', async () => {
+            importLibrary
+                .mockRejectedValueOnce(new Error('places unavailable'))
+                .mockResolvedValueOnce(placesLibrary);
+
+            const loader = new NewGooglePlacesApiScriptLoader();
+
+            await expect(loader.loadPlacesLibrary('foo')).rejects.toThrow('places unavailable');
+
+            const library = await loader.loadPlacesLibrary('foo');
+
+            expect(library).toBe(placesLibrary);
+            expect(importLibrary).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('#loadMapsSdk()', () => {
+        it('reuses the same underlying library promise as loadPlacesLibrary, without loading a second script', async () => {
+            const importLibrary = jest.fn().mockResolvedValue(placesLibrary);
+
+            (window as MutableWindow).google = { maps: { importLibrary } };
+
+            const loader = new NewGooglePlacesApiScriptLoader();
+
+            await loader.loadPlacesLibrary('foo');
+
+            const sdk = await loader.loadMapsSdk('foo');
+
+            expect(importLibrary).toHaveBeenCalledTimes(1);
+            expect(sdk).toEqual({
+                places: {
+                    AutocompleteService: placesLibrary.AutocompleteService,
+                    PlacesService: placesLibrary.PlacesService,
+                },
+            });
+        });
+    });
+
+    describe('when importLibrary is missing', () => {
+        it('bootstraps the Maps JS loader so importLibrary becomes available', () => {
+            const loader = new NewGooglePlacesApiScriptLoader();
+
+            // The bootstrap installs `importLibrary` synchronously; the returned promise stays
+            // pending until the injected script fires its callback (never, in jsdom), so we do
+            // not await it here.
+            loader.loadPlacesLibrary('foo').catch(() => undefined);
+
+            expect(typeof (window as MutableWindow).google.maps.importLibrary).toBe('function');
+
+            const script = document.head.querySelector<HTMLScriptElement>(
+                'script[src*="maps.googleapis.com"]',
+            );
+
+            expect(script).not.toBeNull();
+            expect(script?.src).toContain('key=foo');
+            expect(script?.src).toContain('libraries=places');
+            expect(script?.src).toContain('callback=google.maps.__ib__');
+        });
+    });
+});
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.ts
new file mode 100644
index 0000000000..5dc37cae03
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiScriptLoader.ts
@@ -0,0 +1,106 @@
+interface MapsBootstrapConfig {
+    key: string;
+    v: string;
+    language?: string;
+}
+
+import { type GoogleMapsSdk } from '../googleAutocompleteTypes';
+
+/**
+ * Google's official inline Maps JavaScript API bootstrap loader based on:
+ * https://developers.google.com/maps/documentation/javascript/load-maps-js-api
+ *
+ * This loader is only ever reached when the new-Places-API experiment flag is on for a
+ * store. Stores with the flag off never construct or call this class, so they keep loading
+ * the Maps JS API exactly as they do today, via GoogleAutocompleteScriptLoader.
+ *
+ * When the flag IS on, both the new Places API classes and the legacy
+ * AutocompleteService/PlacesService classes (used as the permission-denied fallback) must
+ * share this same loader instance/promise. Google's Maps JS API does not tolerate being
+ * loaded twice on one page - injecting a second <script> tag via the legacy loader after
+ * this one has already run causes the legacy fallback itself to become unreliable. The
+ * `loadMapsSdk` adapter below lets GoogleAutocompleteService reuse the same cached
+ * `loadPlacesLibrary` promise instead of loading its own script.
+ */
+function bootstrapGoogleMapsImportLibrary({ key, v, language }: MapsBootstrapConfig): void {
+    const CALLBACK_KEY = '__ib__';
+    const doc = document;
+    const globalScope = window as Record<string, any>;
+    const googleNs = (globalScope.google = globalScope.google || {});
+    const mapsNs = (googleNs.maps = googleNs.maps || {});
+
+    if (typeof mapsNs.importLibrary === 'function') {
+        return;
+    }
+
+    const requestedLibraries = new Set<string>();
+    let loadPromise: Promise<void> | undefined;
+
+    const loadScript = (): Promise<void> => {
+        if (loadPromise) {
+            return loadPromise;
+        }
+
+        loadPromise = new Promise<void>((resolve, reject) => {
+            const params = new URLSearchParams({
+                key,
+                v,
+                callback: `google.maps.${CALLBACK_KEY}`,
+                libraries: [...requestedLibraries].join(','),
+            });
+
+            if (language) {
+                params.set('language', language);
+            }
+
+            const script = doc.createElement('script');
+
+            script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+            script.nonce = doc.querySelector<HTMLScriptElement>('script[nonce]')?.nonce ?? '';
+            script.onerror = () =>
+                reject(new Error('The Google Maps JavaScript API could not load.'));
+            mapsNs[CALLBACK_KEY] = resolve;
+            doc.head.append(script);
+        });
+
+        return loadPromise;
+    };
+
+    mapsNs.importLibrary = (library: string, ...rest: unknown[]): Promise<unknown> => {
+        requestedLibraries.add(library);
+
+        return loadScript().then(() => mapsNs.importLibrary(library, ...rest));
+    };
+}
+
+export class NewGooglePlacesApiScriptLoader {
+    private _placesPromise?: Promise<google.maps.PlacesLibrary>;
+
+    loadPlacesLibrary(apiKey: string): Promise<google.maps.PlacesLibrary> {
+        if (this._placesPromise) {
+            return this._placesPromise;
+        }
+
+        // `importLibrary` is the single entry point for the new Places classes.
+        if (typeof google === 'undefined' || typeof google.maps?.importLibrary !== 'function') {
+            bootstrapGoogleMapsImportLibrary({ key: apiKey, v: 'weekly', language: 'en' });
+        }
+
+        this._placesPromise = (
+            google.maps.importLibrary('places') as Promise<google.maps.PlacesLibrary>
+        ).catch((e) => {
+            this._placesPromise = undefined;
+            throw e;
+        });
+
+        return this._placesPromise;
+    }
+
+    // Adapter so GoogleAutocompleteService (legacy AutocompleteService/PlacesService) can be
+    // handed this loader and reuse the already-loaded script instead of loading its own.
+    loadMapsSdk(apiKey: string): Promise<GoogleMapsSdk> {
+        return this.loadPlacesLibrary(apiKey).then(({ AutocompleteService, PlacesService }) => ({
+            places: { AutocompleteService, PlacesService },
+        }));
+    }
+}
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.test.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.test.ts
new file mode 100644
index 0000000000..eb4086ca99
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.test.ts
@@ -0,0 +1,203 @@
+import { type NewGooglePlacesApiScriptLoader } from './NewGooglePlacesApiScriptLoader';
+
+import { NewGooglePlacesApiService } from './NewGooglePlacesApiService';
+
+const mockPlaceAddressComponents = [
+    { longText: 'New South Wales', shortText: 'NSW', types: ['administrative_area_level_1'] },
+    { longText: 'Australia', shortText: 'AU', types: ['country'] },
+];
+
+const mockFetchFields = jest.fn().mockResolvedValue(undefined);
+
+const mockPlaceFromPrediction = {
+    fetchFields: mockFetchFields,
+    addressComponents: mockPlaceAddressComponents,
+    displayName: '123 Main St',
+};
+
+const mockToPlace = jest.fn().mockReturnValue(mockPlaceFromPrediction);
+
+const mockSuggestions = [
+    {
+        placePrediction: {
+            placeId: 'place-1',
+            text: { text: '123 Main St, NY', matches: [] },
+            mainText: { text: '123 Main St' },
+            toPlace: mockToPlace,
+        },
+    },
+];
+
+const MockPlace = jest.fn().mockImplementation(({ id }: { id: string }) => ({
+    id,
+    fetchFields: mockFetchFields,
+    addressComponents: mockPlaceAddressComponents,
+    displayName: '123 Main St',
+}));
+
+const MockSessionToken = jest.fn().mockImplementation(() => ({}));
+
+const mockPlacesLibrary = {
+    AutocompleteSuggestion: {
+        fetchAutocompleteSuggestions: jest.fn().mockResolvedValue({ suggestions: mockSuggestions }),
+    },
+    AutocompleteSessionToken: MockSessionToken,
+    Place: MockPlace,
+};
+
+const mockScriptLoader = {
+    loadPlacesLibrary: jest.fn().mockResolvedValue(mockPlacesLibrary),
+} as unknown as NewGooglePlacesApiScriptLoader;
+
+describe('NewGooglePlacesApiService', () => {
+    let service: NewGooglePlacesApiService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        service = new NewGooglePlacesApiService('test-api-key', mockScriptLoader);
+    });
+
+    describe('getSuggestions', () => {
+        it('returns suggestions mapped to AutocompleteItems', async () => {
+            const result = await service.getSuggestions('123 Main', ['address']);
+
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({ id: 'place-1', label: '123 Main St, NY' });
+        });
+
+        it('passes input and mapped types to fetchAutocompleteSuggestions', async () => {
+            await service.getSuggestions('123 Main', ['address']);
+
+            expect(
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions,
+            ).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    input: '123 Main',
+                    includedPrimaryTypes: ['street_address'],
+                }),
+            );
+        });
+
+        it('maps a string country restriction to includedRegionCodes array', async () => {
+            await service.getSuggestions('123 Main', ['address'], { country: 'US' });
+
+            expect(
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions,
+            ).toHaveBeenCalledWith(expect.objectContaining({ includedRegionCodes: ['US'] }));
+        });
+
+        it('maps an array country restriction to includedRegionCodes', async () => {
+            await service.getSuggestions('123 Main', ['address'], { country: ['US', 'CA'] });
+
+            expect(
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions,
+            ).toHaveBeenCalledWith(expect.objectContaining({ includedRegionCodes: ['US', 'CA'] }));
+        });
+
+        it('omits includedRegionCodes when no componentRestrictions provided', async () => {
+            await service.getSuggestions('123 Main', ['address']);
+
+            expect(
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions,
+            ).toHaveBeenCalledWith(expect.objectContaining({ includedRegionCodes: undefined }));
+        });
+    });
+
+    describe('getPlaceDetails', () => {
+        it('fetches place details via the SDK with the mapped field mask', async () => {
+            await service.getPlaceDetails('place-1', ['addressComponents', 'displayName']);
+
+            expect(MockPlace).toHaveBeenCalledWith({ id: 'place-1' });
+            expect(mockFetchFields).toHaveBeenCalledWith({
+                fields: ['addressComponents', 'displayName'],
+            });
+        });
+
+        it('translates legacy snake_case field names into SDK field names', async () => {
+            await service.getPlaceDetails('place-1', ['address_components', 'name']);
+
+            expect(mockFetchFields).toHaveBeenCalledWith({
+                fields: ['addressComponents', 'displayName'],
+            });
+        });
+
+        it('uses default fields when none provided', async () => {
+            await service.getPlaceDetails('place-1');
+
+            expect(mockFetchFields).toHaveBeenCalledWith({
+                fields: ['addressComponents', 'displayName'],
+            });
+        });
+
+        it('maps addressComponents to the legacy GeocoderAddressComponent shape', async () => {
+            const result = await service.getPlaceDetails('place-1');
+
+            expect(result.address_components).toEqual([
+                {
+                    long_name: 'New South Wales',
+                    short_name: 'NSW',
+                    types: ['administrative_area_level_1'],
+                },
+                { long_name: 'Australia', short_name: 'AU', types: ['country'] },
+            ]);
+        });
+
+        it('maps displayName to the name field', async () => {
+            const result = await service.getPlaceDetails('place-1');
+
+            expect(result.name).toBe('123 Main St');
+        });
+
+        it('rejects when fetchFields fails', async () => {
+            mockFetchFields.mockRejectedValueOnce(new Error('Maps JS auth failed'));
+
+            await expect(service.getPlaceDetails('place-1')).rejects.toThrow('Maps JS auth failed');
+        });
+
+        it('falls back to a tokenless Place lookup when no matching prediction is cached', async () => {
+            await service.getPlaceDetails('unknown-place');
+
+            expect(MockPlace).toHaveBeenCalledWith({ id: 'unknown-place' });
+            expect(mockToPlace).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('session tokens', () => {
+        it('creates a session token and passes it to fetchAutocompleteSuggestions', async () => {
+            await service.getSuggestions('123 Main', ['address']);
+
+            expect(MockSessionToken).toHaveBeenCalledTimes(1);
+            expect(
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions,
+            ).toHaveBeenCalledWith(expect.objectContaining({ sessionToken: expect.any(Object) }));
+        });
+
+        it('reuses the same token across keystrokes within one session', async () => {
+            await service.getSuggestions('1', ['address']);
+            await service.getSuggestions('12', ['address']);
+
+            expect(MockSessionToken).toHaveBeenCalledTimes(1);
+
+            const { calls } =
+                mockPlacesLibrary.AutocompleteSuggestion.fetchAutocompleteSuggestions.mock;
+
+            expect(calls[0][0].sessionToken).toBe(calls[1][0].sessionToken);
+        });
+
+        it('concludes the session via the prediction toPlace() and starts a fresh token next time', async () => {
+            await service.getSuggestions('123 Main', ['address']);
+
+            const result = await service.getPlaceDetails('place-1');
+
+            // Resolved through the cached prediction, not a freshly constructed Place.
+            expect(mockToPlace).toHaveBeenCalledTimes(1);
+            expect(MockPlace).not.toHaveBeenCalled();
+            expect(result.name).toBe('123 Main St');
+
+            // The next address entry opens a brand-new session.
+            await service.getSuggestions('456 Oak', ['address']);
+
+            expect(MockSessionToken).toHaveBeenCalledTimes(2);
+        });
+    });
+});
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.ts
new file mode 100644
index 0000000000..64ea8d811b
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/NewGooglePlacesApiService.ts
@@ -0,0 +1,103 @@
+import type { AutocompleteItem } from '@bigcommerce/checkout/ui';
+
+import type { GoogleAutocompleteOptionTypes } from '../googleAutocompleteTypes';
+
+import getNewGooglePlacesApiScriptLoader from './getNewGooglePlacesApiScriptLoader';
+import { type NewGooglePlacesApiScriptLoader } from './NewGooglePlacesApiScriptLoader';
+import {
+    mapLegacyToNewIncludedPrimaryTypes,
+    mapLegacyToNewPlaceDetailsFieldMask,
+    mapNewToLegacyGeocoderAddressComponent,
+    mapSuggestionsToAutocompleteItems,
+} from './utils';
+
+export class NewGooglePlacesApiService {
+    private _sessionToken?: google.maps.places.AutocompleteSessionToken;
+    private _predictionsById = new Map<string, google.maps.places.PlacePrediction>();
+
+    constructor(
+        private _apiKey: string,
+        private _scriptLoader: NewGooglePlacesApiScriptLoader = getNewGooglePlacesApiScriptLoader(),
+    ) {}
+
+    async getSuggestions(
+        input: string,
+        types: GoogleAutocompleteOptionTypes[] | undefined,
+        componentRestrictions?: google.maps.places.ComponentRestrictions,
+    ): Promise<AutocompleteItem[]> {
+        const { AutocompleteSuggestion, AutocompleteSessionToken } =
+            await this._scriptLoader.loadPlacesLibrary(this._apiKey);
+
+        if (!this._sessionToken) {
+            this._sessionToken = new AutocompleteSessionToken();
+        }
+
+        const includedRegionCodes = this.convertToRegionCodes(componentRestrictions?.country);
+        const includedPrimaryTypes = mapLegacyToNewIncludedPrimaryTypes(types ?? ['geocode']);
+
+        const { suggestions } = await AutocompleteSuggestion.fetchAutocompleteSuggestions({
+            input,
+            includedPrimaryTypes,
+            includedRegionCodes,
+            sessionToken: this._sessionToken,
+        });
+
+        this.cachePredictions(suggestions);
+
+        return mapSuggestionsToAutocompleteItems(suggestions);
+    }
+
+    async getPlaceDetails(
+        placeId: string,
+        fields?: string[],
+    ): Promise<google.maps.places.PlaceResult> {
+        const place = await this.resolvePlace(placeId);
+
+        await place.fetchFields({ fields: mapLegacyToNewPlaceDetailsFieldMask(fields) });
+
+        // Fetching details ends the autocomplete session; the next entry starts fresh.
+        this.resetSession();
+
+        return {
+            address_components: place.addressComponents?.map(
+                mapNewToLegacyGeocoderAddressComponent,
+            ),
+            name: place.displayName ?? '',
+        };
+    }
+
+    private async resolvePlace(placeId: string): Promise<google.maps.places.Place> {
+        const prediction = this._predictionsById.get(placeId);
+
+        if (prediction) {
+            return prediction.toPlace();
+        }
+
+        const { Place } = await this._scriptLoader.loadPlacesLibrary(this._apiKey);
+
+        return new Place({ id: placeId });
+    }
+
+    private cachePredictions(suggestions: google.maps.places.AutocompleteSuggestion[]): void {
+        for (const { placePrediction } of suggestions) {
+            if (placePrediction) {
+                this._predictionsById.set(placePrediction.placeId, placePrediction);
+            }
+        }
+    }
+
+    private resetSession(): void {
+        this._sessionToken = undefined;
+        this._predictionsById.clear();
+    }
+
+    private convertToRegionCodes(
+        country: string | string[] | null | undefined,
+    ): string[] | undefined {
+        if (!country) {
+            return undefined;
+        }
+
+        return Array.isArray(country) ? country : [country];
+    }
+}
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/getNewGooglePlacesApiScriptLoader.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/getNewGooglePlacesApiScriptLoader.ts
new file mode 100644
index 0000000000..03d27842b4
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/getNewGooglePlacesApiScriptLoader.ts
@@ -0,0 +1,11 @@
+import { NewGooglePlacesApiScriptLoader } from './NewGooglePlacesApiScriptLoader';
+
+let instance: NewGooglePlacesApiScriptLoader;
+
+export default function getNewGooglePlacesApiScriptLoader(): NewGooglePlacesApiScriptLoader {
+    if (!instance) {
+        instance = new NewGooglePlacesApiScriptLoader();
+    }
+
+    return instance;
+}
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/index.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/index.ts
new file mode 100644
index 0000000000..bf2ee4045b
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/index.ts
@@ -0,0 +1,2 @@
+export { default as getNewGooglePlacesApiScriptLoader } from './getNewGooglePlacesApiScriptLoader';
+export { NewGooglePlacesApiService } from './NewGooglePlacesApiService';
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.test.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.test.ts
new file mode 100644
index 0000000000..aa74e0dc72
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.test.ts
@@ -0,0 +1,145 @@
+import {
+    isNewPlacesApiPermissionDenied,
+    mapLegacyToNewIncludedPrimaryTypes,
+    mapLegacyToNewPlaceDetailsFieldMask,
+    mapNewToLegacyGeocoderAddressComponent,
+    mapSuggestionsToAutocompleteItems,
+} from './utils';
+
+describe('mapLegacyToNewPlaceDetailsFieldMask', () => {
+    it('maps legacy snake_case field names to new-API camelCase names', () => {
+        expect(mapLegacyToNewPlaceDetailsFieldMask(['address_components', 'name'])).toEqual([
+            'addressComponents',
+            'displayName',
+        ]);
+    });
+
+    it('passes through new-API field names unchanged', () => {
+        expect(mapLegacyToNewPlaceDetailsFieldMask(['addressComponents', 'displayName'])).toEqual([
+            'addressComponents',
+            'displayName',
+        ]);
+    });
+
+    it('de-duplicates fields that map to the same name', () => {
+        expect(mapLegacyToNewPlaceDetailsFieldMask(['name', 'displayName'])).toEqual([
+            'displayName',
+        ]);
+    });
+
+    it('defaults to address components and display name when none provided', () => {
+        expect(mapLegacyToNewPlaceDetailsFieldMask()).toEqual(['addressComponents', 'displayName']);
+        expect(mapLegacyToNewPlaceDetailsFieldMask([])).toEqual([
+            'addressComponents',
+            'displayName',
+        ]);
+    });
+});
+
+describe('mapLegacyToNewIncludedPrimaryTypes', () => {
+    it('maps "address" to "street_address"', () => {
+        expect(mapLegacyToNewIncludedPrimaryTypes(['address'])).toEqual(['street_address']);
+    });
+
+    it('keeps "establishment" as-is', () => {
+        expect(mapLegacyToNewIncludedPrimaryTypes(['establishment'])).toEqual(['establishment']);
+    });
+
+    it('returns undefined for "geocode" (no direct equivalent)', () => {
+        expect(mapLegacyToNewIncludedPrimaryTypes(['geocode'])).toBeUndefined();
+    });
+
+    it('filters out null-mapped types and returns the rest', () => {
+        expect(mapLegacyToNewIncludedPrimaryTypes(['geocode', 'address'])).toEqual([
+            'street_address',
+        ]);
+    });
+
+    it('returns undefined for an empty array', () => {
+        expect(mapLegacyToNewIncludedPrimaryTypes([])).toBeUndefined();
+    });
+});
+
+describe('mapSuggestionsToAutocompleteItems', () => {
+    it('maps a suggestion to an autocomplete item', () => {
+        const mockSuggestions: google.maps.places.AutocompleteSuggestion[] = [
+            {
+                placePrediction: {
+                    placeId: 'place-1',
+                    text: {
+                        text: '123 Main St, New York',
+                        matches: [{ startOffset: 0, endOffset: 3 }],
+                    },
+                    mainText: { text: '123 Main St' },
+                } as google.maps.places.PlacePrediction,
+            },
+        ];
+
+        const items = mapSuggestionsToAutocompleteItems(mockSuggestions);
+
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({
+            id: 'place-1',
+            label: '123 Main St, New York',
+            value: '123 Main St',
+            highlightedSlices: [{ offset: 0, length: 3 }],
+        });
+    });
+
+    it('skips suggestions without placePrediction', () => {
+        const mockSuggestionsWithoutPlacePrediction: google.maps.places.AutocompleteSuggestion[] = [
+            { placePrediction: null },
+        ];
+
+        expect(mapSuggestionsToAutocompleteItems(mockSuggestionsWithoutPlacePrediction)).toEqual(
+            [],
+        );
+    });
+});
+
+describe('mapNewToLegacyGeocoderAddressComponent', () => {
+    it('maps an AddressComponent to a GeocoderAddressComponent', () => {
+        const addressComponentMock = {
+            longText: 'New York',
+            shortText: 'NY',
+            types: ['locality', 'political'],
+        } as google.maps.places.AddressComponent;
+
+        expect(mapNewToLegacyGeocoderAddressComponent(addressComponentMock)).toEqual({
+            long_name: 'New York',
+            short_name: 'NY',
+            types: ['locality', 'political'],
+        });
+    });
+
+    it('falls back to empty strings and empty array when fields are missing', () => {
+        const component = {} as google.maps.places.AddressComponent;
+
+        expect(mapNewToLegacyGeocoderAddressComponent(component)).toEqual({
+            long_name: '',
+            short_name: '',
+            types: [],
+        });
+    });
+});
+
+describe('isNewPlacesApiPermissionDenied', () => {
+    it('returns true for an RpcError with PERMISSION_DENIED (code 7)', () => {
+        expect(isNewPlacesApiPermissionDenied({ name: 'RpcError', code: 7 })).toBe(true);
+    });
+
+    it('returns false for an RpcError with some transient code', () => {
+        expect(isNewPlacesApiPermissionDenied({ name: 'RpcError', code: 14 })).toBe(false);
+    });
+
+    it('returns false for a non-RpcError carrying code 7', () => {
+        expect(isNewPlacesApiPermissionDenied({ name: 'TypeError', code: 7 })).toBe(false);
+    });
+
+    it('returns false for unrelated error shapes and non-objects', () => {
+        expect(isNewPlacesApiPermissionDenied(new Error('boom'))).toBe(false);
+        expect(isNewPlacesApiPermissionDenied(undefined)).toBe(false);
+        expect(isNewPlacesApiPermissionDenied(null)).toBe(false);
+        expect(isNewPlacesApiPermissionDenied('PERMISSION_DENIED')).toBe(false);
+    });
+});
diff --git a/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.ts b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.ts
new file mode 100644
index 0000000000..47b9889300
--- /dev/null
+++ b/packages/core/src/app/address/googleAutocomplete/newGooglePlacesApi/utils.ts
@@ -0,0 +1,73 @@
+import { type AutocompleteItem } from '@bigcommerce/checkout/ui';
+
+import { type GoogleAutocompleteOptionTypes } from '../googleAutocompleteTypes';
+
+const LEGACY_TO_NEW_TYPE_MAP: Record<GoogleAutocompleteOptionTypes, string | null> = {
+    geocode: null,
+    address: 'street_address',
+    establishment: 'establishment',
+};
+
+const LEGACY_TO_NEW_FIELD_MAP: Record<string, string> = {
+    address_components: 'addressComponents',
+    name: 'displayName',
+};
+
+export const mapLegacyToNewIncludedPrimaryTypes = (
+    legacyTypes: GoogleAutocompleteOptionTypes[],
+): string[] | undefined => {
+    const mapped = legacyTypes
+        .map((legacyType) => LEGACY_TO_NEW_TYPE_MAP[legacyType])
+        .filter((newType): newType is string => newType !== null);
+
+    return mapped.length > 0 ? mapped : undefined;
+};
+
+export const mapSuggestionsToAutocompleteItems = (
+    suggestions: google.maps.places.AutocompleteSuggestion[],
+): AutocompleteItem[] =>
+    suggestions.flatMap((suggestion) => {
+        const { placePrediction } = suggestion;
+
+        if (!placePrediction) return [];
+
+        return [
+            {
+                label: placePrediction.text?.text ?? '',
+                value: placePrediction.mainText?.text ?? '',
+                highlightedSlices: (placePrediction.text?.matches ?? []).map(
+                    ({ startOffset, endOffset }) => ({
+                        offset: startOffset,
+                        length: endOffset - startOffset,
+                    }),
+                ),
+                id: placePrediction.placeId,
+            },
+        ];
+    });
+
+export const mapLegacyToNewPlaceDetailsFieldMask = (fields?: string[]): string[] => {
+    const source = fields?.length ? fields : ['address_components', 'name'];
+
+    return Array.from(new Set(source.map((field) => LEGACY_TO_NEW_FIELD_MAP[field] ?? field)));
+};
+
+export const mapNewToLegacyGeocoderAddressComponent = (newAddressComponent: {
+    longText?: string | null;
+    shortText?: string | null;
+    types?: string[] | null;
+}): google.maps.GeocoderAddressComponent => ({
+    long_name: newAddressComponent.longText ?? '',
+    short_name: newAddressComponent.shortText ?? '',
+    types: newAddressComponent.types ?? [],
+});
+
+// places.googleapis.com is gRPC-Web, so failures arrive as an `RpcError` with a numeric gRPC status `code`.
+// Code 7 is a consistent PERMISSION_DENIED and not anything transient
+const GRPC_PERMISSION_DENIED = 7;
+
+export const isNewPlacesApiPermissionDenied = (error: unknown): boolean => {
+    const rpcError = error as { name?: unknown; code?: unknown } | null | undefined;
+
+    return rpcError?.name === 'RpcError' && rpcError.code === GRPC_PERMISSION_DENIED;
+};