Networking & Developer Handbook

AI Tools Access Guide

Troubleshoot by region, account, network, and how you access the tool. If you haven’t set up the 9WVPN client yet, follow the Quick Start to install it, import your subscription, and verify the connection. If you’re connected but the tool still reports an error, continue with the relevant section of this guide.

Platform eligibility and feature access

First, identify the specific feature you’re trying to use. Opening the ChatGPT sign-in page, returning to an existing conversation, uploading a file in the app, and calling a model programmatically are different access scenarios. Even within the same product, account eligibility, workspace permissions, supported regions, and billing rules may be assessed separately. When troubleshooting, note the product, entry point, and feature—for example, the web chat opens but file submission fails. Don’t just write “this AI doesn’t work.” If you need help from an administrator later, these details point directly to the relevant settings.

Check official guidance for the specific feature—not assumptions based on the brand

Start with the provider’s help center to check which regions support the product entry point you’re using. Then confirm your plan, account type, and any organization requirements. A product’s marketing page loading only shows that your current environment received a response from that page; it doesn’t establish API eligibility or mean a particular model is available. If official guidance doesn’t mention a feature, check the in-account feature menu, administrator assignment records, or support response. Don’t treat someone else’s screenshot as proof that your account has access. The table below lists what to verify; it isn’t a live availability list.

Check feature permissions by product entry point
ToolEntry points to distinguishCheck first
ChatGPTWeb chat, developer APIWorkspace, project permissions, and billing settings for each
ClaudeWeb app, developer consoleOrganization associated with the account and access to the target model
GeminiConsumer app, developer or cloud project entry pointGoogle account type and service settings for the selected project
CopilotMicrosoft Copilot、GitHub CopilotSign-in identity, license, and organization policies for the specific product
MidjourneyWeb workspace and linked access pointsIdentity linking, account entitlements, and task status
CursorFeatures in the editor, separately configured model accessEditor sign-in, team policies, and the actual request destination

Distinguish regional eligibility from feature and content restrictions

Egress IP may be one input in regional checks, but the result can also depend on account details, organization location, project settings, or the product’s own eligibility requirements. Browser language is a display preference; changing it doesn’t change regional eligibility. Organization members may also face administrator restrictions: being able to upload files in a colleague’s personal workspace doesn’t mean uploads are allowed in the company workspace. Before comparing results, confirm both users have the same account type and are testing the same entry point and feature. This helps prevent organization settings from being mistaken for a route issue.

Pay attention to when the error appears. If the page says before submission that the region isn’t supported, follow the provider’s official requirements and stop retrying that entry point. If the information doesn’t match what you see, save the exact message and check through official support. If chat works but a particular type of content is refused, review the product policy and task instead of changing routes to alter a content decision. If a new feature is missing, first confirm it’s available to your account, plan, or administrator; then check whether the page has fully loaded.

Choose a non-sensitive task for testing

For an initial test, use short, repeatable text. Don’t upload work documents or use real images or source code as test data. To test document features, create a blank sample yourself and add a single sentence of public text. This separates “the task itself triggered a restriction” from “the upload feature isn’t working” and avoids exposing client information in any screenshots you may later share. Results apply only to the entry point and conditions tested; one successful short chat doesn’t confirm that longer generations, file processing, or team features work.

For products that require switching workspaces, check which identity is active on the page before testing. The browser’s account menu, the editor’s account menu, and the cloud console’s project selector may each retain a previous choice. The same email address may also be associated with a personal space and an organization-managed one. When sharing results, note the selected workspace and feature, but don’t include member details in shared documents. The clearer the actual entry point is, the less likely it is that results from different permission contexts will get mixed up during follow-up.

Egress IP and the network path

Accessing an AI website often involves more than opening one site. The initial page, authentication, static assets, uploads, and generation requests may go to different destinations. If the browser receives the page shell but the conversation list never appears, at least some requests have succeeded; it’s not necessarily a total loss of connectivity. Conversely, if the local machine can’t resolve the domain at all, repeatedly refreshing the sign-in page won’t provide new evidence. First identify the earliest failure: DNS resolution, connection setup, certificate validation, sign-in redirect, or reading the response after submitting a request.

Check which process used which route

Start by observing the browser you’re using to test—not the connection indicator in the client. In the same browser, open the site’s IP Check and note the displayed egress IP and time, then return to the tool and reproduce the issue. The check shows the route used to reach the check service; it doesn’t prove that an IDE, terminal, embedded browser, or target API uses the same route. If the browser and client show different results, check for separate proxy settings, per-app rules, or organization network policies. Focus on the process actually making the request rather than changing network settings across the whole device.

The displayed egress region is only a clue. Databases may label the same address differently, and the site’s check doesn’t mean a third-party platform uses the same data source. IP risk checks are also different from regional eligibility: a provider may add checks for unusual sessions, traffic patterns from shared egress IPs, or inconsistent sign-in environments, even when the address appears to be in a supported region. Follow official steps when a security check appears. Until it’s complete, don’t repeatedly switch egress IPs or add new devices and sign-in identities to the same test.

Separate DNS issues from certificate issues

If the error says the host name can’t be found, first verify the domain spelling against the official entry point. Then check whether the app uses system DNS, the browser’s own DNS settings, or DNS resolution through a proxy. A successful terminal lookup proves only that this particular terminal query returned a result; it doesn’t show that the app uses the same resolution path. Existing connections and cached data can also delay changes after switching networks. Note the app and network in use, then reopen the affected page after making an adjustment. Avoid changing several things at once, so you can retrace your steps.

If the browser explicitly reports an untrusted certificate, a name mismatch, or an unusual validity period, first check the system clock, the domain you’re visiting, and whether a public network is still awaiting sign-in. For managed devices behind a security gateway, ask the administrator to verify the trust settings and scope. Don’t disable certificate validation to open a page or install root certificates from unknown sources. If you see a suspected fake page or can’t explain a certificate error, stop entering account details and investigate from a trusted device or managed environment.

Compare routes for your use case; coverage isn’t a guarantee

Where permitted by the provider and your network environment, open the Server page to compare regions and route types. Relay, direct, and IEPL describe different ways a route is organized; the type alone can’t tell you whether a third-party feature is available. Keep the device, account, and test task the same, changing only one condition at a time. For text chat, check whether the first part of the response arrives and whether output continues. For file tasks, check separately whether the upload completes, processing starts, and the result can be retrieved.

If the issue comes and goes, check whether it coincides with waking from sleep, switching networks, or a regular time of day. Simply noting “it worked after I switched” doesn’t rule out a change in platform load or the effect of an old connection closing. More useful details include where the original request stalled, whether reconnecting restored it at that same step, and whether other destinations were affected at the same time. If several observations point to the same condition, contact the route provider with your notes. Otherwise, keep it as a hypothesis to verify.

Account sign-up and sign-in sessions

Your 9WVPN account and AI platform accounts are managed separately. 9WVPN doesn’t require an email address; create an account with a username and password. Third-party tools have their own sign-up requirements or organization invitations. First confirm whether you’re setting up the 9WVPN client, signing in to an AI website, or authorizing an AI platform identity in an editor. The verification pages may look similar, but never enter a subscription link, account password, or recovery details for one service into another service’s form.

Start from the official entry point and confirm your account

Use the official entry point provided by the service or organization, enter accurate information as required by the platform, and keep a recovery method you can access. If you already have an account, use the sign-in method you used before. An identity created through organization sign-in may not be the same as a personal identity created manually through another entry point. Invited members can ask their administrator which identity received the invitation, whether it was accepted, and whether a license has been assigned. Seeing “No workspace” doesn’t mean the account doesn’t exist; you may be in a personal space or the organization invitation may not have been completed.

First-time sign-ins, resuming a session after travel, and using an editor on a new device can all trigger extra security checks. Before entering credentials, check the address bar and site identity. Keep the current tab and connection environment in place until the check is complete, rather than repeatedly starting new sign-in flows. Use a password manager to save a unique password for each site. If the platform offers multi-factor authentication, enable it and store recovery materials securely offline. Don’t approve a sign-in confirmation you didn’t initiate; check existing sessions through a trusted entry point.

For redirect loops, check the callback—not just the password

A sign-in flow may open an identity provider before returning to the original app. If it keeps cycling between the sign-in and authorization pages, note the last domain that opened successfully, whether the browser blocked a pop-up, and whether the flow returned to the app that started sign-in. Privacy extensions, site data restrictions, and expired sessions can all interrupt the process. If authorization rules allow, try a clean browser profile for comparison or check settings for the relevant sites only. There’s no need to clear data for every site or disable browser protections globally.

When an editor starts authorization, it may open a page in the system browser and hand the result back to the editor when complete. If the browser says sign-in succeeded but the editor still asks you to sign in, check whether the browser prompted you to open the app, whether it opened the version you’re using, and whether the organization restricts external callbacks. Remote desktops, containers, and remote development hosts can also mean the initiating and receiving processes run in different environments. Use the tool’s supported sign-in flow and official diagnostics. Don’t share an authorization callback URL or paste screenshots containing session parameters into a support ticket.

Distinguish expired sessions, account issues, and organization changes

Long-open tabs may retain an expired session. If an old page fails but a newly opened official entry point lets you sign in, confirm your current account and workspace on the new page, then use the app’s normal sign-out flow to refresh the old session. If you see a credentials error, use the official recovery process rather than repeatedly trying different passwords. If you receive an alert about an unfamiliar device, review active sessions from a trusted environment, revoke any you don’t recognize, and update your credentials as instructed by the platform. Then check whether member permissions in the same organization have changed.

When investigating lost permissions, team administrators should first check recent personnel changes, license removals, and organization security policies rather than assuming the network changed. If the project still exists but one member can’t access it, compare member assignments and sign-in identities. If the whole team is affected, check plan status, the identity provider, or platform announcements first. In a support request, clearly describe the account notification, the last entry point that worked, and the failing steps. Don’t share full sign-in records, recovery codes, or subscription links. For credential safety, see the guide to subscription links and public network safety.

Streaming responses and file tasks

An AI website opening successfully doesn’t mean it can reliably deliver generated results. Initial page loads usually involve requests of limited duration, while streaming sends data gradually over a single response. A gateway in between may wait until it has accumulated enough data before forwarding it, or close the connection after a period without incoming data. So “nothing appears for a while, then it all shows up at once,” “the response starts and then stops,” and “the first part never appears” are different issues. Recording exactly where it fails is more useful than simply saying “it’s slow.”

First distinguish no response from a mid-stream disconnect

Start with a short, non-sensitive prompt. Check whether the task enters a generating state, whether the first part appears, and whether it finishes normally. Where possible, keep the same account, workspace, and entry point, and reproduce the issue with an example of the same length. If no output appears at all, check platform queuing, whether the request was sent, a delayed server response, or buffering in an intermediary. If output starts and then stops, investigate idle timeouts, device sleep, network switching, or a server-side stop. Compare the start and completion stages; page load speed isn’t a substitute for how the response behaves.

If the platform has an official status page, check the specific product and incident window rather than relying on an overall status color. The browser developer tools’ Network panel can show which request is waiting, canceled, or returning an error. Open the panel before reproducing the issue, and initially note only the request type, status, and time—don’t copy full request headers. Apps may use server-sent events, ordinary streaming responses, or a separate real-time session channel. Check the platform documentation and actual behavior; don’t assume that text appearing gradually means the app uses WebSocket.

Test longer responses and attachments after short text works

Keep a successful short-text example, then test a longer response with nonessential content. Note whether it always stops at a similar point. If output is interrupted when switching wireless networks or waking a device, but a new request succeeds, a broken old connection is more likely than an account permission issue. Don’t repeatedly click regenerate. First check whether the original task is still running, especially if it can incur costs or write results. If the platform offers a resume or continue option, use its documented behavior; don’t assume that refreshing will either discard or preserve the result.

Break file tasks into file selection, upload completion, processing, and result retrieval. If the file is rejected immediately after selection, check its format, permissions, and whether it’s within the platform’s allowed file scope. If progress advances and then stalls, check the upload connection and device state. If it keeps waiting after upload completes, check whether the task is queued or parsing failed. Testing again with a shorter document in an accepted sample format can help separate content issues from transfer issues. Don’t upload workplace documents to a personal workspace for testing, and don’t attach original files to external support tickets.

Proxies and buffering in managed environments

If an administrator confirms that only requests through the organization’s gateway arrive in batches, compare the timing of similar requests before and after the gateway. Ask the administrator to check whether the relevant route has response buffering, an idle timeout, and a total connection time limit. These settings serve different purposes: the total limit controls how long the entire request can run, the idle timeout determines whether to close a connection after a period without data, and buffering affects when received content is passed to the client. Don’t simply increase every timeout. Adjust the specific business route within your authorized scope, then check resource use and effects on other traffic.

Also distinguish streaming from page rendering. If the Network panel shows the response finishing on time but the interface freezes in just one browser, keep the same network and task and compare that browser with a clean profile. Extensions, editor rendering, and local resources can all affect display. If the issue disappears in a comparison that doesn’t change the network, the evidence points more toward the app. If you change both browser and network, you can’t draw that conclusion.

API requests and error categories

A working web app only shows that the current web session meets the relevant access conditions. API requests also depend on developer project access, model permissions, key authorization, and quota checks. Before configuring a request, check the provider’s documentation for the official API endpoint, authentication method, and request fields. In the developer console, confirm project ownership, billing status, and available models. Don’t extract credentials from a web session for use in a program, or copy request fields directly from one platform to another. Similar-looking APIs don’t necessarily share permissions, error formats, or streaming event definitions.

Diagnose errors by the stage where they occur

If the client hasn’t received an HTTP response, start with DNS, the connection, certificates, and proxy settings. Once a response arrives, check the status, error body, and request ID. The categories below are starting points for diagnosis, not rules for drawing conclusions from a status code alone: a corporate gateway may generate an error page, and a client library may group different underlying errors into the same exception. Check that the response format matches the provider’s documentation; don’t mistake a proxy’s sign-in page for an API permission error.

Choose the next step based on what you see
SymptomEvidence to check firstNext step
No response receivedDNS, handshake, or connection errorCheck the requesting process and its network path
Authentication or authorization failedProject, role, and key scopeVerify credential ownership and model access; don’t blindly retry
Rate limited or quota exhaustedError details, quota dashboard, and retry guidanceReduce request rate as instructed, or address billing and quota
Partial output receivedLast event received and reason the client exitedCheck timeout settings, stream-reading logic, and completion conditions

Test connectivity without credentials and send a minimal request

Run the command below in a terminal with curl to make a standard HTTPS request to an example domain. It discards the response body and prints only the status and timings for DNS resolution, the handshake, and the first byte. Each timing is cumulative from the start of the request, not an independent duration you can add to the others. This only helps verify basic connectivity from the current terminal; it doesn’t test the target API or check model permissions. If it succeeds but your application still fails, the next step is to make a minimal application request in an authorized environment, following the provider’s documentation—not to substitute an unknown endpoint.

curl -sS -o /dev/null \
  -w 'http=%{http_code} dns=%{time_namelookup} tls=%{time_appconnect} first=%{time_starttransfer}\n' \
  https://example.com/

This syntax is for Unix-like shells. On Windows, use curl.exe, replace the null device with NUL, and follow the current shell’s line-break rules or put the command on one line. If an error means a timing value isn’t valid, check the error text to see whether the request reached that stage. With a proxy or connection reuse, some values may describe only the part of the path visible to the client; they aren’t the target service’s full internal processing time. Don’t use this as a release gate: reaching the example site doesn’t prove that your application’s dependencies are reachable.

Keep diagnostic logs separate from production credentials

For a minimal application request, start with a model you’re authorized to use and a short input. Confirm a non-streaming response before enabling streaming so you can pinpoint differences. Supply keys through the operating system’s credential store, controlled environment variables, or a secrets manager. Don’t put them in a repository, command history, or front-end page. Prefer logs that record a project alias, failure stage, request ID, and necessary status details. Don’t include request bodies, authorization headers, or URLs containing credentials in shared logs. Share diagnostic snippets with support only if the platform confirms they contain no secrets and you’ve checked them.

When adding timeouts and cancellation to production requests, distinguish between the client giving up and the server confirming it stopped. The former doesn’t mean remote processing has ended. Before resending a task that incurs charges or writes data, check its status. Use an idempotency option only if the platform explicitly supports it, and follow its documentation. For streaming requests, record whether partial content was delivered and mark it as incomplete in the UI. This prevents the client from silently making another request and duplicating results and costs.

CLI, IDE, and CI configuration

In a development environment, what matters isn’t which window says “connected,” but where the process making the request runs. If the CLI runs locally, an IDE extension runs on a remote host, and a CI job runs on a hosted runner, each has its own DNS path, proxy settings, certificate trust, and permissions. Even if all three use the same code, you can’t assume local diagnostics apply to them. First map the path—requesting process → network boundary → target API—then investigate the relevant runtime environment.

CLI: Check that variables are set in the current process

Common proxy environment variables include HTTPS_PROXY, HTTP_PROXY, and NO_PROXY, but whether a client reads them, their priority, and how it matches exceptions depend on the client. Check the tool’s documentation first, then confirm the variables are set in the shell running the command or in the configuration used to start the service. GUI apps may not inherit terminal variables, and already running processes don’t update automatically. Check only whether a variable is set and whether the destination falls within an exception. Don’t print the full variable value to the screen or logs; the proxy URL itself may contain credentials.

If the request took the wrong path, first determine whether the client’s configuration overrides environment variables or whether an exception list matched the destination. Make one change at a time in a test environment and record the result. Don’t add an entire production domain scope to an exception list. Keep temporary settings limited to the test process and remove them afterward. If the certificate chain is invalid, install verified trust material using the approved method for the managed device or runtime. Don’t hide the issue by disabling validation or upload a trust file exported from another device with your code.

IDE: Identify the extension host and sign-in callback

AI features in Cursor and other editors may send requests from the main process, extension host, or remote workspace. Check whether the plugin is installed locally or in a remote workspace, then open the relevant process’s output log to see whether the failure is in the sign-in callback, model request, indexing, or upload. Successful authentication in the system browser doesn’t prove that the extension host can call the API. If sign-in works but project actions fail, also check team policies and which files the editor is allowed to send.

Start with a blank or public sample project. Turn off automatic indexing and background tasks you don’t need for this diagnostic so concurrent traffic doesn’t affect the results. If the sample works but the work project doesn’t, check organization policies, project size, ignore lists, and permissions. Don’t copy the project to a personal account to test it. After setting a proxy configuration supported by the tool, reload the relevant processes as instructed and repeat the same operation. Note the original values before making changes, and revert only the changes made for this test.

CI: Set up egress, credentials, and failure handling separately

CI jobs run on runners; they don’t inherit a developer’s computer egress IP or local settings. Check that the runner’s region and outbound policy meet the platform’s requirements and your organization’s rules. Confirm that the container can resolve the official domain and trusts organization-approved certificates. An internal proxy may not be reachable from the runner, especially if it’s bound to localhost. First verify the basic path without credentials, then make a minimal request from a controlled test project. Record which runner type and step failed.

Store application keys using the secrets mechanism provided by CI, and restrict them to protected jobs that need them. Workflows triggered by external contributions shouldn’t have access to production keys. Avoid debug modes that echo environment values or request headers, and restrict access to build artifacts and failure logs. If you only need to test request formatting and parsing, use a sample response instead of calling an external model on every run. When testing the real API is necessary, set concurrency limits and timeouts, and decide in advance whether to stop the workflow or mark the check as temporarily unverifiable if the dependency is unavailable. This avoids mistaking an external incident for a code regression and prevents reruns from driving up usage.

Rate limits, account restrictions, and reviews

“Unable to continue right now” could mean requests are arriving too frequently, the project has insufficient quota, the account needs a security check, or the provider has suspended a permission. Each needs a different response. Read the full error and account notifications, then check the developer console, workspace status, and official service announcements. Treat it as a rate limit only when there’s clear evidence. If the message says the account is suspended or ineligible, don’t substitute automatic retries for a review.

Rate limits: Reduce load where requests originate

Rate limits may apply to a project, model, or organization, and may be calculated by request count, input volume, or concurrent in-flight tasks. First identify which level the error refers to. If different apps in the same organization start failing at once, check shared quotas. If only one batch job fails, start with its concurrency and request size. If the platform gives a wait time, follow it. If there’s no explicit wait guidance and the documentation says the error is retryable, increase the wait gradually and add a small random delay to prevent multiple jobs from resuming at once and adding to congestion.

Retries should have a limit on attempts or duration, and stop when a cancellation signal arrives. A shared queue makes load easier to monitor than letting every worker retry independently. For regular interactive use, show a retry-later or queued status so users don’t keep submitting without feedback. When testing reduced load, keep the same project and request category and see whether errors decrease as in-flight tasks fall. Don’t rotate accounts, keys, or egress IPs to evade limits. That makes logs and billing harder to reconcile and may violate platform rules.

Insufficient quota: Adjust billing or usage, rather than waiting

If the error points to a budget, project usage limit, or billing status, check the alert in the management console first. Queuing can help with a short-lived spike, but repeated retries after waiting won’t usually help when the budget is exhausted. Check whether batch jobs have exceeded their planned usage, especially through automatic retries after timeouts, full batch reruns after failures, or tool loops. You can pause the job and compare request records with the bill to understand what changed. Budget adjustments or quota requests should be handled by someone with the required permissions.

An input that’s too long may also exceed request limits; waiting for a usage window to reset won’t fix that. Check the platform’s input limits, metering rules, and model settings. Remove repeated context, split separate tasks, and define how to combine the results. Don’t remove essential safety constraints or error checks just to reduce input. Once within the provider’s permitted request limits, test the output quality with a small sample to make sure the result isn’t missing important context.

Account restrictions: Preserve evidence and use official review channels

If an account is restricted, first distinguish a security check from an organization policy or a notice about the provider’s policies. A temporary security check may require identity confirmation; an administrator should investigate changes to organization permissions; for a suspended or closed account, use the appeal or review channel in the notice. Understanding and following the platform’s eligibility requirements, account-sharing policies, content rules, and automation limits helps prevent avoidable issues. Don’t repeatedly create accounts or keep switching sign-in environments, and don’t borrow another member’s credentials to complete a task.

If you suspect a key has been exposed, revoke the at-risk key through a trusted entry point, update legitimate tasks that depend on it, and review suspicious requests and charges. A report can include the time, project, containment steps taken, and any remaining questions, but not the exposed value. If organization policy blocked a request, tell the administrator its purpose, data category, and required permissions. Let them decide whether access can be granted or an approved alternative workflow used, rather than handling data in a personal environment that should stay within the organization.

Troubleshooting sequence and handoff

A thorough investigation starts with a reproducible description. Note the platform, entry point, workspace type, runtime environment, and action that failed, followed by what you expected to happen. Instead of saying “Claude won’t connect,” say whether the website opens but returns to the sign-in page, or whether you reach the workspace but generation never starts. Instead of “Cursor has a network issue,” specify whether it’s sign-in in the local editor, a request from a remote extension, or a workspace upload. Describe what you can observe without assuming the cause in the title.

Follow the evidence, rather than trying things at random

  1. Confirm eligibility. Check the official regional guidance, account type, and feature permissions. If the feature isn’t supported, stop comparing network routes. If the documentation conflicts with the message, note when it occurred and request a review.
  2. Find the earliest failure. For DNS failures, check the network; for a failed sign-in redirect, check the session or callback; for a clear permission error, check the project and organization. Keep the exact error message rather than summarizing everything as “can’t connect.”
  3. Change one variable at a time. Keep the same account, entry point, and non-sensitive task, changing only the condition you’re investigating. Record whether the issue is reproducible after the change and what happens when you revert it.
  4. Retest the original scenario. After basic access works, return to the original task type and check whether attachments, long responses, or remote execution also work. Don’t mark the issue resolved just because the home page opens.

For example, if web chat works but the API request from a terminal gets no response, check DNS and proxy settings in the actual terminal environment and confirm that it uses the organization’s required network. Don’t start by clearing browser site data. Conversely, if the terminal receives a project permission error from the official API, that request reached a layer capable of returning an error; first verify who returned it and check project authorization. If multiple devices experience the same issue on the same platform, compare service status and team configuration changes rather than having each person repeatedly adjust routes.

Identify which service is responsible before deciding whom to contact

The AI platform or workspace administrator can explain account eligibility, model access, and content-handling errors. Check the developer console or ask the project owner about a project’s request quota and billing. Device or network administrators should handle local certificates, organization gateways, and runner egress. For help with the 9WVPN client, subscription, or connection, visit the relevant channel on the Support page. If the connection isn’t set up yet, go back to Quick Start and follow the steps in order rather than repeatedly importing the same subscription into different clients.

If you choose 9WVPN, compare monthly subscriptions and data packages on the Pricing page. Monthly subscription data resets each month on the activation date; data packages last until used and never expire. When estimating your needs, consider whether text, attachments, and background sync all use the same connection, and choose based on actual usage records. You can also read how to choose between data packages and monthly plans. Network subscriptions are independent of AI platform feature permissions and API quotas. Upgrading a network plan won’t change third-party workspace permissions.

Include the necessary evidence in your handoff

When reporting an issue, include the time with time zone, product entry point, system and runtime location, a summary of the error, whether any output arrived, and the most useful comparison test. For API requests, you can include the request ID generated by the platform, but never include authorization headers, passwords, subscription links, full callback URLs, or raw request bodies. Crop screenshots to remove account details, workspace identifiers, and conversation content. Use a public sample to reproduce the issue if possible. If detailed logs must be shared, redact them according to your organization’s rules and use a private channel approved by the support team.

After resolving the issue, record the configuration that actually changed and what you observed. If a platform incident cleared on its own and you found no local cause, write “restored; cause unconfirmed” rather than saying the route was fixed. Revoke any test permissions or temporary proxy settings introduced during troubleshooting. Teams can keep a troubleshooting record with no secrets, noting the owner, retest entry point, and known limitations. When similar symptoms occur again, start with the evidence rather than copying the previous conclusion.