diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.test.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.test.tsx
index 03a1b0bced..60aeb0d45c 100644
--- a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.test.tsx
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.test.tsx
@@ -160,7 +160,6 @@ describe('TokenRequiredModal', () => {
       const cancelButton = await screen.findByRole('button', { name: /Cancel/ })
       await user.click(cancelButton)
 
-      expect(setTokenRequired).toHaveBeenCalledWith(false)
       await waitFor(() => expect(closeModal).toHaveBeenCalled())
     })
   })
diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.tsx
index 60be641874..91dd41bb3b 100644
--- a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.tsx
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenRequiredModal.tsx
@@ -8,7 +8,7 @@ interface TokenlessModalProps {
   isLoading: boolean
 }
 
-const TokenlessModal = ({
+const TokenRequiredModal = ({
   closeModal,
   setTokenRequired,
   isLoading,
@@ -50,7 +50,6 @@ const TokenlessModal = ({
         <Button
           hook="cancel-token-requirement"
           onClick={() => {
-            setTokenRequired(false)
             closeModal()
           }}
           to={undefined}
@@ -76,4 +75,4 @@ const TokenlessModal = ({
   />
 )
 
-export default TokenlessModal
+export default TokenRequiredModal
diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.test.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.test.tsx
index b0348f878d..fad9fe44a9 100644
--- a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.test.tsx
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.test.tsx
@@ -1,61 +1,141 @@
-import { render, screen } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
+import { graphql, HttpResponse } from 'msw2'
+import { setupServer } from 'msw2/node'
 import { MemoryRouter, Route } from 'react-router-dom'
 
 import TokenlessSection from './TokenlessSection'
 
-const Wrapper: React.FC<React.PropsWithChildren> = ({ children }) => (
-  <MemoryRouter initialEntries={['/account/github/codecov/org-upload-token']}>
-    <Route path="/account/:provider/:owner/org-upload-token">{children}</Route>
-  </MemoryRouter>
+const mocks = vi.hoisted(() => ({
+  useAddNotification: vi.fn(),
+  useFlags: vi.fn(),
+}))
+
+vi.mock('services/toastNotification', async () => {
+  const actual = await vi.importActual('services/toastNotification')
+  return {
+    ...actual,
+    useAddNotification: mocks.useAddNotification,
+  }
+})
+
+vi.mock('shared/featureFlags', async () => {
+  const actual = await vi.importActual('shared/featureFlags')
+  return {
+    ...actual,
+    useFlags: mocks.useFlags,
+  }
+})
+
+const queryClient = new QueryClient({
+  defaultOptions: { queries: { retry: false } },
+})
+
+const server = setupServer()
+
+beforeAll(() => {
+  console.error = () => {}
+  server.listen()
+})
+
+beforeEach(() => {
+  server.resetHandlers()
+  queryClient.clear()
+})
+
+afterAll(() => server.close())
+
+const wrapper: React.FC<React.PropsWithChildren> = ({ children }) => (
+  <QueryClientProvider client={queryClient}>
+    <MemoryRouter initialEntries={['/account/gh/codecov/org-upload-token']}>
+      <Route path="/account/:provider/:owner/org-upload-token">
+        {children}
+      </Route>
+    </MemoryRouter>
+  </QueryClientProvider>
 )
 
 describe('TokenlessSection', () => {
-  const setup = () => {
+  function setup({
+    isAdmin = true,
+    orgUploadToken = 'test-mock-org-upload-token',
+    uploadTokenRequired = false,
+  } = {}) {
+    mocks.useFlags.mockReturnValue({ tokenlessSection: true })
+    mocks.useAddNotification.mockReturnValue(vi.fn())
+    const mutate = vi.fn()
     const user = userEvent.setup()
 
-    return { user }
+    server.use(
+      graphql.query('GetUploadTokenRequired', () => {
+        return HttpResponse.json({
+          data: {
+            owner: {
+              orgUploadToken,
+              isAdmin,
+              uploadTokenRequired,
+            },
+          },
+        })
+      }),
+      graphql.mutation('SetUploadTokenRequired', (info) => {
+        mutate(info.variables.input.uploadTokenRequired)
+
+        return HttpResponse.json({
+          data: {
+            setUploadTokenRequired: {
+              error: null,
+            },
+          },
+        })
+      })
+    )
+
+    return { user, mutate }
   }
 
-  it('renders the token authentication title', () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
+  it('renders the token authentication title', async () => {
     setup()
+    render(<TokenlessSection />, { wrapper })
 
-    const title = screen.getByText('Token authentication')
+    const title = await screen.findByText('Token authentication')
     expect(title).toBeInTheDocument()
   })
 
-  it('renders the learn more link', () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
+  it('renders the learn more link', async () => {
     setup()
+    render(<TokenlessSection />, { wrapper })
 
-    const learnMoreLink = screen.getByText('learn more')
+    const learnMoreLink = await screen.findByText('learn more')
     expect(learnMoreLink).toBeInTheDocument()
   })
 
-  it('renders the authentication option selection text', () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
+  it('renders the authentication option selection text', async () => {
     setup()
+    render(<TokenlessSection />, { wrapper })
 
-    const optionText = screen.getByText('Select an authentication option')
+    const optionText = await screen.findByText(
+      'Select an authentication option'
+    )
     expect(optionText).toBeInTheDocument()
   })
 
-  it('renders "Not required" option description', () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
+  it('renders "Not required" option description', async () => {
     setup()
+    render(<TokenlessSection />, { wrapper })
 
-    const notRequiredDescription = screen.getByText(
+    const notRequiredDescription = await screen.findByText(
       'When a token is not required, your team can upload coverage reports without one. Existing tokens will still work, and no action is needed for past uploads. Designed for public open-source projects.'
     )
     expect(notRequiredDescription).toBeInTheDocument()
   })
 
-  it('renders "Required" option description', () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
+  it('renders "Required" option description', async () => {
     setup()
+    render(<TokenlessSection />, { wrapper })
 
-    const requiredDescription = screen.getByText(
+    const requiredDescription = await screen.findByText(
       'When a token is required, your team must use a global or repo-specific token for uploads. Designed for private repositories and closed-source projects.'
     )
     expect(requiredDescription).toBeInTheDocument()
@@ -63,77 +143,101 @@ describe('TokenlessSection', () => {
 
   describe('when "Required" option is selected', () => {
     it('renders the "Cancel" button', async () => {
-      render(<TokenlessSection />, { wrapper: Wrapper })
       const { user } = setup()
+      render(<TokenlessSection />, { wrapper })
 
-      const requiredOption = screen.getByLabelText('Required')
+      const requiredOption = await screen.findByLabelText('Required')
       await user.click(requiredOption)
 
-      const cancelButton = screen.getByRole('button', { name: /Cancel/ })
+      const cancelButton = await screen.findByRole('button', { name: /Cancel/ })
       expect(cancelButton).toBeInTheDocument()
     })
 
     it('renders the "Require token for upload" button', async () => {
-      render(<TokenlessSection />, { wrapper: Wrapper })
       const { user } = setup()
+      render(<TokenlessSection />, { wrapper })
 
-      const requiredOption = screen.getByLabelText('Required')
+      const requiredOption = await screen.findByLabelText('Required')
       await user.click(requiredOption)
 
-      const requireTokenButton = screen.getByRole('button', {
+      const requireTokenButton = await screen.findByRole('button', {
         name: /Require token for upload/,
       })
       expect(requireTokenButton).toBeInTheDocument()
     })
 
     it('removes modal and defaults to not required when "Cancel" button is clicked', async () => {
-      render(<TokenlessSection />, { wrapper: Wrapper })
       const { user } = setup()
+      render(<TokenlessSection />, { wrapper })
 
-      const requiredOption = screen.getByLabelText('Required')
+      const requiredOption = await screen.findByLabelText('Required')
       await user.click(requiredOption)
 
-      const cancelButton = screen.getByRole('button', { name: /Cancel/ })
+      const cancelButton = await screen.findByRole('button', { name: /Cancel/ })
       await user.click(cancelButton)
 
-      const notRequiredOption = screen.getByLabelText('Not required')
+      const notRequiredOption = await screen.findByLabelText('Not required')
       expect(notRequiredOption).toBeChecked()
     })
 
-    it('removes modal and switches to required when "Require token for upload" button is clicked', async () => {
-      render(<TokenlessSection />, { wrapper: Wrapper })
-      const { user } = setup()
+    describe('when "Require token for upload" button is clicked', () => {
+      it('removes modal and switches to required when "Require token for upload" button is clicked', async () => {
+        const { user } = setup()
+        render(<TokenlessSection />, { wrapper })
 
-      const requiredOption = screen.getByLabelText('Required')
-      await user.click(requiredOption)
+        const requiredOption = await screen.findByLabelText('Required')
+        await user.click(requiredOption)
 
-      const requireTokenButton = screen.getByRole('button', {
-        name: /Require token for upload/,
+        const requireTokenButton = await screen.findByRole('button', {
+          name: /Require token for upload/,
+        })
+        expect(requireTokenButton).toBeInTheDocument()
       })
-      await user.click(requireTokenButton)
 
-      const requiredOptionAfterClick = screen.getByLabelText('Required')
-      expect(requiredOptionAfterClick).toBeChecked()
+      it('switches to required', async () => {
+        const { user } = setup()
+        render(<TokenlessSection />, { wrapper })
+
+        const requiredOption = await screen.findByLabelText('Required')
+        await user.click(requiredOption)
+
+        const requireTokenButton = await screen.findByRole('button', {
+          name: /Require token for upload/,
+        })
+        await user.click(requireTokenButton)
+
+        const requiredOptionAfterClick =
+          await screen.findByLabelText('Required')
+        expect(requiredOptionAfterClick).toBeChecked()
+      })
     })
   })
 
-  it("switches to 'Not required' option when not required is selected", async () => {
-    render(<TokenlessSection />, { wrapper: Wrapper })
-    const { user } = setup()
+  describe('when switching to "Not required" option', () => {
+    it('switches to "Not required" option', async () => {
+      const { user } = setup({ uploadTokenRequired: true })
+      render(<TokenlessSection />, { wrapper })
+
+      const requiredOption = await screen.findByLabelText('Required')
+      await waitFor(() => {
+        expect(requiredOption).toBeChecked()
+      })
 
-    const requiredOption = screen.getByLabelText('Required')
-    await user.click(requiredOption)
+      const notRequiredOption = await screen.findByLabelText('Not required')
+      await user.click(notRequiredOption)
 
-    const requireTokenButton = screen.getByRole('button', {
-      name: /Require token for upload/,
+      expect(notRequiredOption).toBeChecked()
     })
 
-    await user.click(requireTokenButton)
-    expect(requiredOption).toBeChecked()
-    const notRequiredOption = screen.getByLabelText('Not required')
-    expect(notRequiredOption).not.toBeChecked()
+    it('calls mutate with false', async () => {
+      const { user, mutate } = setup({ uploadTokenRequired: true })
+      render(<TokenlessSection />, { wrapper })
+
+      const notRequiredOption = await screen.findByLabelText('Not required')
+      await user.click(notRequiredOption)
 
-    await user.click(notRequiredOption)
-    expect(notRequiredOption).toBeChecked()
+      expect(mutate).toHaveBeenCalledTimes(1)
+      expect(mutate).toHaveBeenCalledWith(false)
+    })
   })
 })
diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.tsx
index d69b059a49..987c8b1a35 100644
--- a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.tsx
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/TokenlessSection.tsx
@@ -1,25 +1,52 @@
-import { useState } from 'react'
+import { useEffect, useState } from 'react'
+import { useParams } from 'react-router-dom'
 
+import { useUploadTokenRequired } from 'services/uploadTokenRequired'
 import A from 'ui/A'
 import { Card } from 'ui/Card'
 import { RadioTileGroup } from 'ui/RadioTileGroup'
 
-import TokenlessModal from './TokenRequiredModal'
+import TokenRequiredModal from './TokenRequiredModal'
+import { useSetUploadTokenRequired } from './useSetUploadTokenRequired'
 
 const AUTHENTICATION_OPTIONS = {
   NotRequired: 'not-required',
   Required: 'required',
 } as const
 
-function TokenlessSection() {
-  const [showModal, setShowModal] = useState(false)
-  const [tokenRequired, setTokenRequired] = useState(false) // TODO: get from API
+interface UseParams {
+  provider: string
+  owner: string
+}
+
+const TokenlessSection: React.FC = () => {
+  const { provider, owner } = useParams<UseParams>()
+  const {
+    data: uploadTokenRequiredData,
+    isLoading: isUploadTokenRequiredLoading,
+  } = useUploadTokenRequired({ provider, owner })
+  const { mutate, isLoading: isSetUploadTokenRequiredLoading } =
+    useSetUploadTokenRequired()
+
+  const [showModal, setShowModal] = useState<boolean>(false)
+  const [tokenRequired, setTokenRequiredState] = useState<boolean>(true)
+
+  useEffect(() => {
+    if (
+      !isUploadTokenRequiredLoading &&
+      uploadTokenRequiredData &&
+      uploadTokenRequiredData?.uploadTokenRequired !== null
+    ) {
+      setTokenRequiredState(uploadTokenRequiredData.uploadTokenRequired)
+    }
+  }, [uploadTokenRequiredData, isUploadTokenRequiredLoading])
 
   const handleValueChange = (value: string) => {
     if (value === AUTHENTICATION_OPTIONS.Required) {
       setShowModal(true)
     } else {
-      setTokenRequired(false)
+      setTokenRequiredState(false)
+      mutate(false)
     }
   }
 
@@ -30,7 +57,7 @@ function TokenlessSection() {
           <h2 className="text-sm font-semibold">Token authentication</h2>
           <A
             to={{
-              pageName: 'aboutCodeCoverage', // TODO: replace with actual pageName
+              pageName: 'tokenlessDocs',
             }}
             hook="tokenless-docs"
             isExternal={true}
@@ -75,10 +102,13 @@ function TokenlessSection() {
           </RadioTileGroup.Item>
         </RadioTileGroup>
         {showModal && (
-          <TokenlessModal
+          <TokenRequiredModal
             closeModal={() => setShowModal(false)}
-            setTokenRequired={setTokenRequired}
-            isLoading={false} // TODO: get from API
+            setTokenRequired={(value) => {
+              setTokenRequiredState(value)
+              mutate(true)
+            }}
+            isLoading={isSetUploadTokenRequiredLoading}
           />
         )}
       </Card.Content>
diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.test.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.test.tsx
new file mode 100644
index 0000000000..3423f88f75
--- /dev/null
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.test.tsx
@@ -0,0 +1,177 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { renderHook, waitFor } from '@testing-library/react'
+import { graphql, HttpResponse } from 'msw2'
+import { setupServer } from 'msw2/node'
+import { MemoryRouter, Route } from 'react-router-dom'
+
+import { useSetUploadTokenRequired } from './useSetUploadTokenRequired'
+
+const mocks = vi.hoisted(() => ({
+  useAddNotification: vi.fn(),
+}))
+
+vi.mock('services/toastNotification', async () => {
+  const actual = await vi.importActual('services/toastNotification')
+  return {
+    ...actual,
+    useAddNotification: mocks.useAddNotification,
+  }
+})
+
+const server = setupServer()
+
+beforeAll(() => {
+  server.listen()
+})
+
+afterEach(() => {
+  server.resetHandlers()
+})
+
+afterAll(() => {
+  server.close()
+})
+
+const queryClient = new QueryClient({
+  defaultOptions: { queries: { retry: false } },
+})
+
+const wrapper: React.FC<React.PropsWithChildren> = ({ children }) => (
+  <MemoryRouter initialEntries={['/gh/codecov']}>
+    <Route path="/:provider/:owner">
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    </Route>
+  </MemoryRouter>
+)
+
+describe('useSetUploadTokenRequired', () => {
+  function setup({ isErrorResponse = false }) {
+    const mockAddToast = vi.fn()
+    mocks.useAddNotification.mockReturnValue(mockAddToast)
+
+    server.use(
+      graphql.mutation('SetUploadTokenRequired', () => {
+        if (isErrorResponse) {
+          return HttpResponse.json({
+            data: {
+              setUploadTokenRequired: {
+                error: {
+                  __typename: 'ValidationError',
+                  message: 'Failed to set upload token requirement',
+                },
+              },
+            },
+          })
+        }
+
+        return HttpResponse.json({
+          data: {
+            setUploadTokenRequired: {
+              error: null,
+            },
+          },
+        })
+      })
+    )
+
+    return { mockAddToast }
+  }
+
+  describe('when called', () => {
+    beforeEach(() => {
+      setup({})
+    })
+
+    describe('when calling the mutation', () => {
+      describe('when successful', () => {
+        it('returns isSuccess true', async () => {
+          const { result } = renderHook(() => useSetUploadTokenRequired(), {
+            wrapper,
+          })
+
+          result.current.mutate(true)
+
+          await waitFor(() => result.current.isLoading)
+          await waitFor(() => !result.current.isLoading)
+
+          await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+          const data = result.current.data
+          await waitFor(() =>
+            expect(data).toEqual({
+              data: {
+                setUploadTokenRequired: {
+                  error: null,
+                },
+              },
+            })
+          )
+        })
+
+        it('fires a success toast', async () => {
+          const { mockAddToast } = setup({})
+
+          const { result } = renderHook(() => useSetUploadTokenRequired(), {
+            wrapper,
+          })
+
+          result.current.mutate(true)
+
+          await waitFor(() => result.current.isLoading)
+          await waitFor(() => !result.current.isLoading)
+
+          await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+          await waitFor(() =>
+            expect(mockAddToast).toHaveBeenCalledWith({
+              type: 'success',
+              text: 'Upload token requirement updated successfully',
+              disappearAfter: 10000,
+            })
+          )
+        })
+      })
+
+      describe('on error', () => {
+        it('fires an error toast', async () => {
+          const { mockAddToast } = setup({ isErrorResponse: true })
+
+          const { result } = renderHook(() => useSetUploadTokenRequired(), {
+            wrapper,
+          })
+
+          result.current.mutate(true)
+
+          await waitFor(() => result.current.isLoading)
+          await waitFor(() => !result.current.isLoading)
+
+          await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+          await waitFor(() =>
+            expect(mockAddToast).toHaveBeenCalledWith({
+              type: 'error',
+              text: 'Failed to set upload token requirement',
+              disappearAfter: 10000,
+            })
+          )
+        })
+      })
+
+      it('does not fire a success toast when isSuccess is falsy', async () => {
+        const { mockAddToast } = setup({})
+
+        const { result } = renderHook(() => useSetUploadTokenRequired(), {
+          wrapper,
+        })
+
+        result.current.mutate(false)
+        await waitFor(() => expect(result.current.isSuccess).toBeFalsy())
+
+        await waitFor(() =>
+          expect(mockAddToast).not.toHaveBeenCalledWith({
+            type: 'error',
+            text: 'An error occurred while updating upload token requirement',
+            disappearAfter: 10000,
+          })
+        )
+      })
+    })
+  })
+})
diff --git a/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.tsx b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.tsx
new file mode 100644
index 0000000000..6fc58813bc
--- /dev/null
+++ b/src/pages/AccountSettings/tabs/OrgUploadToken/TokenlessSection/useSetUploadTokenRequired.tsx
@@ -0,0 +1,78 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import { useParams } from 'react-router-dom'
+
+import { useAddNotification } from 'services/toastNotification'
+import Api from 'shared/api'
+
+const TOAST_DURATION = 10000
+
+const query = `
+  mutation SetUploadTokenRequired($input: SetUploadTokenRequiredInput!) {
+    setUploadTokenRequired(input: $input) {
+      error {
+        __typename
+        ... on ValidationError {
+          message
+        }
+        ... on UnauthorizedError {
+          message
+        }
+        ... on UnauthenticatedError {
+          message
+        }
+      }
+    }
+  }
+`
+
+interface URLParams {
+  provider: string
+  owner: string
+}
+
+export const useSetUploadTokenRequired = () => {
+  const { provider, owner } = useParams<URLParams>()
+  const addToast = useAddNotification()
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (uploadTokenRequired: boolean) => {
+      return Api.graphqlMutation({
+        provider,
+        query,
+        variables: {
+          input: {
+            orgUsername: owner,
+            uploadTokenRequired,
+          },
+        },
+        mutationPath: 'setUploadTokenRequired',
+      })
+    },
+    onSuccess: ({ data }) => {
+      queryClient.invalidateQueries(['GetUploadTokenRequired'])
+      const error = data?.setUploadTokenRequired?.error
+      if (error) {
+        addToast({
+          type: 'error',
+          text: error?.message || 'Failed to set upload token requirement',
+          disappearAfter: TOAST_DURATION,
+        })
+      } else {
+        addToast({
+          type: 'success',
+          text: 'Upload token requirement updated successfully',
+          disappearAfter: TOAST_DURATION,
+        })
+      }
+    },
+    onError: () => {
+      addToast({
+        type: 'error',
+        text: 'An error occurred while updating upload token requirement',
+        disappearAfter: TOAST_DURATION,
+      })
+    },
+    retry: false,
+  })
+}
diff --git a/src/services/navigation/useNavLinks/useStaticNavLinks.js b/src/services/navigation/useNavLinks/useStaticNavLinks.js
index c7a0cb3111..b52561475e 100644
--- a/src/services/navigation/useNavLinks/useStaticNavLinks.js
+++ b/src/services/navigation/useNavLinks/useStaticNavLinks.js
@@ -499,5 +499,12 @@ export function useStaticNavLinks() {
       text: 'Bundle analysis feedback survey',
       isExternalLink: true,
     },
+    tokenlessDocs: {
+      text: 'Tokenless Uploads',
+      path: () =>
+        'https://docs.codecov.com/docs/codecov-tokens#uploading-without-a-token',
+      isExternalLink: true,
+      openNewTab: true,
+    },
   }
 }
diff --git a/src/services/navigation/useNavLinks/useStaticNavLinks.test.jsx b/src/services/navigation/useNavLinks/useStaticNavLinks.test.jsx
index a37d95f302..e553495fde 100644
--- a/src/services/navigation/useNavLinks/useStaticNavLinks.test.jsx
+++ b/src/services/navigation/useNavLinks/useStaticNavLinks.test.jsx
@@ -96,6 +96,7 @@ describe('useStaticNavLinks', () => {
       ${links.teamPlanFeedbackSurvey}        | ${'https://docs.google.com/forms/d/e/1FAIpQLSeoMHPyECewV7X3UaT-uUxZCmYy1T6hEX_aecCD2ppPHGSvUw/viewform'}
       ${links.proPlanFeedbackSurvey}         | ${'https://forms.gle/nf37sRAtyQeXVTdr8'}
       ${links.bundleFeedbackSurvey}          | ${'https://forms.gle/8fzZrwWEaBRz4ufD9'}
+      ${links.tokenlessDocs}                 | ${'https://docs.codecov.com/docs/codecov-tokens#uploading-without-a-token'}
     `('static links return path', ({ link, outcome }) => {
       it(`${link.text}: Returns the correct link`, () => {
         expect(link.path()).toBe(outcome)