AI Troubleshooting Guide · Connectivity and Diagnostics
AI Tools Access Guide
A page loading doesn't mean you can sign in—or that an API request will keep returning data. When diagnosing an AI tool connection, first check whether the feature is available to your account and region. Then distinguish sign-in issues from delays before the first response and interruptions during streaming.
If you haven't installed the client or imported your subscription yet, start with the Guides. If you're connected but a tool or feature isn't working, use this guide to troubleshoot step by step. If you find an issue with importing your subscription or granting system permissions, return to the guide and check the steps for your platform.
Why AI tools are sensitive to network conditions
When you use an AI tool, different systems may handle the page, authentication, model requests, file uploads, and result downloads. The entry point usually loads the page framework and static assets first; the actual model request may not start until the session is ready. So “the homepage loads,” “I can open a chat,” “the request was sent,” and “I received the full response” are separate checkpoints. When reporting a problem, identify the last action that succeeded instead of lumping everything together as “can't connect.”
Your exit IP is a signal, not your account identity
The service sees the address that actually sends the request. A browser, desktop app, and background task on the same device may use different network settings and leave through different exit IPs. Public IP geolocation databases are maintained independently and don't update in sync. If the region shown by your client differs from an IP lookup or the platform's own region assessment, note the discrepancy rather than treating any one label as proof of account eligibility.
A change in exit IP, along with a device record, existing session, or recent sign-in activity, may trigger an additional verification step. That's one possible explanation—not proof of an IP reputation issue. Try confirming your identity through the official entry point in an environment you normally use and that the platform supports. If the prompt persists, save its wording and check official account notifications. Avoid repeated sign-ins or frequent region changes to investigate the IP; they add more variables.
Check regional availability separately from account permissions
A platform may define separate availability for its web product, developer API, mobile app, and individual features. Workspace administrator permissions, billing eligibility, and feature access may also be assessed independently. Check the official availability information for the specific product mentioned in the error, then review your workspace and permissions in the account you're using. If your location or organization doesn't meet the requirements, ask the platform or administrator about approved options, or use an authorized alternative. Network settings can't change eligibility.
One easy-to-misread case: a colleague can see a feature, but it doesn't appear in your account. First check whether you're both using the same product, organization, and sign-in method, then compare the feature documentation. A missing entry point usually can't be explained by latency. If the entry point is present but hangs when clicked, check whether a request was sent, whether a page script was blocked, and whether the backend returned a specific error.
Track time to first response separately from interruptions
A generation involves establishing a connection, submitting input, waiting for the service to start responding, receiving content, and detecting completion. A slow first response may be caused by input size, service queueing, or request forwarding. If content arrives and then stops, check whether the connection dropped, an intermediary closed an idle connection, the client cancelled the request, or the platform ended the response normally. Reporting both as “slow internet” groups fundamentally different issues together.
To establish a baseline, start a short text-only chat in a supported environment—no attachments or external tools—and wait for the interface to show completion. Then test the problematic feature under the same session conditions. Note when the page changes, where the result stops, and whether a retry prompt appears. You can record what happened without saving the prompt itself. If only complex tasks fail, don't assume the route is at fault; check attachment limits, model processing time, and whether a tool is waiting on an external system.
Availability requirements vary by AI tool
When comparing tools, don't rely on a region list that claims to stay valid indefinitely. Check the current product entry point, account eligibility, and specific feature instead. The steps below are organized by use case; they aren't a platform support guarantee, and an accessible page doesn't prove that a model or feature is available.
| Tool | Where to access it | Check first |
|---|---|---|
| ChatGPT | Chat website or app | Personal account or workspace; check API access separately |
| Claude | Chat product or developer platform | Availability of the relevant product, organization, and model permissions |
| Gemini | Chat product, developer portal, or cloud project | Current account, project permissions, and feature availability |
| Copilot | Microsoft product or GitHub developer tool | Product name, license, and organization policies |
| Midjourney | Creation tools listed in the official documentation | Check account linking, task submission, and result loading separately |
| Cursor | Desktop editor | Editor account, team policies, and request path for the specific feature |
Check the chat product and developer platform separately
For ChatGPT or Claude, first check which account and workspace are active on the relevant website, then see whether a plain-text chat completes. If the developer platform reports an error, separately check the project that sent the request, its target, and its permissions. Chat access in a browser doesn't mean the project used by your code has the same permissions; conversely, API access for a project doesn't prove that browser sign-in is configured correctly. Record the entry point you used, not just the brand name.
Don't mix tests for Gemini personal chat, the developer portal, and cloud projects. For example, if you can sign in to the website with a personal account but an organization project returns a permission error, check which project and identity the API actually uses and whether the target location is allowed by the organization. Switching browser profiles only changes the web session; it may not change the identity used by a terminal. Check the account active in the command-line environment, and ask the project administrator to verify permissions if needed.
For integrated tools, identify which layer returned the error
When reporting a Copilot issue, include the full product name. Assistant features in Microsoft products and GitHub Copilot don't share the same license. For editor autocomplete, for example, confirm after signing in that the extension is using an authorized identity, the organization allows the feature, and the workspace hasn't disabled the extension. If only one repository is affected, compare it with a temporary project that contains no sensitive data, then check repository and enterprise policies. Don't mistake an organization restriction for a route issue.
For Cursor, distinguish editor sign-in, built-in chat, indexing, and terminal tools. Reaching a URL from the integrated terminal only shows that the terminal process can make that request; it says nothing about requests from the editor's background processes. Check whether the selected feature is authorized in the current editor session, then use the official diagnostics view to identify the failing request type. If the issue occurs only in a remote workspace, find out whether requests originate locally or remotely so you don't keep changing settings on the side that isn't sending them.
For media tasks, check submission, results, and downloads separately
Break a Midjourney task into submission, processing, displaying the result, and downloading it. If the task appears in your history after submission, the platform has at least accepted the request. If the results area is blank, check the task status in the official interface and determine whether it's still processing, generation failed, or static assets didn't load. For a failed download, confirm that your current account has access, the download link is still valid, and the organization permits the destination. Don't repeatedly submit the same task just to test a thumbnail.
The same approach works for AI text tools that accept attachments. If a blank chat works but an upload fails, try a sample with no sensitive content that meets the format requirements. Check whether the error occurs before sending, during transfer, or after server-side processing. An error before sending is more likely to be local validation; a rejection after upload should prompt checks of content, format, and permissions. Compare results from the same stage before assessing the effect of the route.
Account creation, authorization, and session renewal
First, distinguish your VPNWhole account from your AI tool account. VPNWhole requires no email address; create an account with a username and password. Authentication, regional eligibility, billing, and organization permissions for AI tools are managed by their respective providers. Your VPNWhole account status doesn't determine the status of an account on another platform, so make sure you contact the right provider about an error.
Verify your identity and organization through official channels
Before creating an account, check the product's availability, terms of use, and requirements for organization accounts. Keep personal and work use separate, and request company resources through internal processes. Open sign-in from a verified official entry point, then check the address bar and account selection page. Don't hand over your login details through unfamiliar forms found in search results. Follow platform and organization rules when saving recovery options. If the platform offers additional verification, configure it before using the account for important work.
When signing in with an organization account, ask the administrator to confirm which account has access instead of checking only that your display name looks right. The same identity may belong to multiple workspaces, and the default workspace may not be the one with a license. If sign-in succeeds but a feature is unavailable, switch to the correct workspace and open the feature again. If you need a license or approval, ask the administrator rather than creating another account to test access.
If sign-in keeps redirecting, check your browser context
Authorization usually redirects from the product to an identity provider, then back to the product to establish a session. If the sign-in page works but the product sends you back to sign-in, the session may not have been saved, the system clock may be off, an extension may have blocked the redirect, or the app may have opened the sign-in page in a different browser from the one receiving the authorization. First make sure your system clock is synchronized. Then start and complete the whole flow in the same browser profile, rather than switching between windows.
If sign-in fails only in one browser profile, retry in a separate profile dedicated to troubleshooting. Keep your normal setup intact and don't clear all site data. Check for strict cross-site state restrictions or extensions that block redirects. If the product requires related permissions, adjust them only for the relevant site, following official guidance and organization policies—don't disable protections globally. If an error page includes query parameters in the redirect URL, don't share the full address; it may contain short-lived authorization data.
Handle expired sessions and security checks separately
If everything worked before but you're asked to sign in again after some time, treat it as a routine session expiry first: keep any unsent, non-sensitive work and reopen the current workspace through the official entry point. If the message changes to “additional verification required” or “account issue,” stop retrying and use the platform's verification or recovery process. Don't reuse someone else's session or import browser state from an unknown source. These actions won't fix authorization and may make the issue harder to investigate.
If you suspect your credentials have been exposed, use a trusted device to open the official security settings, revoke suspicious sessions through the platform's process, update affected credentials, and ask your organization administrator to check for permission changes. If you use team single sign-on, also look for security notices from your identity provider. Regaining access only confirms that one sign-in succeeded; it doesn't prove the account is secure. For sensitive work, wait for the administrator or official process to verify the situation.
Document the issue without exposing your identity
A support report can include the product name, whether it's a personal or organization account, whether the failure happened on the sign-in page or after authorization, and a redacted error message. Also note whether all devices fail or only one browser profile. Send account recovery information only through the official channel. Don't post sign-in screenshots, full redirect URLs, or browser storage contents in public forums. If you made multiple attempts, summarize the time period and actions rather than attaching every session identifier.
Finish with a verification test: after authorization succeeds, reopen the affected feature and start a non-sensitive task to confirm it returns a result in the correct workspace. If you can sign in but the feature still fails, mark the sign-in issue as resolved and follow the later sections for the feature error. This keeps two separate issues from being conflated into repeated configuration changes.
Troubleshooting web apps and interrupted streaming
Web chat doesn't wait for all the text to be generated before showing it. The service can stream results continuously, and the browser renders each piece as it arrives. If a connection closes mid-transfer, you may see partial text, a cursor that keeps waiting, or a reconnect message. Treat result generation and page display as separate events: seeing partial content doesn't mean the final part reached your browser.
Find the failing stage in browser developer tools
Open the Network panel in your browser's developer tools and send a short message with no sensitive information in a blank chat. Check the requests in chronological order: did a request appear, did it return an error, and was it receiving data until the connection closed? Request names in many interfaces don't clearly identify the generation action, so compare the requests added before and after sending. Don't copy or replay full requests that contain identity information. If nothing appears when you send, first check the interface, extensions, and form validation.
A successful response header doesn't prove that the task finished. Keep the Network panel open and check whether the connection is still pending after the interface stops updating, or whether a cancellation message appears. Some platforms also include failure events in the response body. If you can open the same task in product history, check whether the result is complete. A complete history result points to a possible browser display or transfer issue; if the history result is also incomplete, check the platform task status too. This alone doesn't identify which part of the route failed.
Distinguish batched updates from a dropped stream
Several short chunks appearing at once don't necessarily mean data was lost. The app may batch interface updates, or an intermediary may buffer data. If the task completes normally but the display isn't continuous, compare it with the official interface, check whether the browser behaves differently in the foreground and background, and compare actual completion times. If the connection consistently closes after a similar quiet period, note the time from the last received data to closure and ask whoever manages the forwarding layer to check idle timeouts and buffering.
If the issue occurs only after closing the lid, sleep, or switching networks, first check whether the session is still running once the connection is restored, then decide whether to resend. Switching networks can invalidate an existing transfer; the old connection isn't guaranteed to continue. To test long responses reliably, start with a short task in the foreground, then increase the output size. Don't change routes while a response is streaming. Make the switch before sending the request so you don't mistake an intentional interruption for poor route performance.
Test long context, attachments, and external actions separately
If short messages work but long conversations are noticeably slower, start a new chat with only a necessary, non-sensitive summary instead of retrying the entire history. If that works, check whether the context size or an attachment in the conversation is slowing things down. If the same file still causes problems within the supported format and size limits, compare it with a short sample. Check whether the file uploaded, whether analysis is still in progress, and whether an error appears at the end. Add one condition at a time to identify where the failure starts.
A tool call may be waiting for user approval or a response from an external system. A paused interface doesn't mean the text stream is broken. Check for a pending action or a workspace policy that blocks execution. If you can't tell whether an external action already ran, don't retry it repeatedly. Check the source system for a result, then decide whether to resume or cancel. For ordinary chat, send a separate short message to check whether the connection is back.
API connections, timeouts, and retries
Web apps usually handle sign-in, session renewal, streaming display, and some errors for you. With an API, your application must explicitly select the account project, model, streaming mode, and timeout policy. Use the official documentation to choose an API that's permitted for your current project, then build the smallest possible request in a development environment. Add tool calls, concurrency, and long inputs only after it succeeds. Don't use an entire production pipeline as your first connectivity test.
Identify whether the failure occurs during connection or response
If your program doesn't receive response headers, check runtime errors in this order: name resolution, connection setup, and certificate verification. Resolving the address but failing to connect doesn't mean the certificate is misconfigured; completing a handshake but getting no response doesn't tell you from the timeout alone whether the platform accepted the request. If you receive a response, first determine whether it came from the target service or a local gateway or organization forwarding layer. Then consult the relevant documentation. Don't treat every permission error as the same authentication failure.
For a structured error from the platform, check whether the credentials are invalid, the project lacks permission, the model isn't enabled, or the input is invalid. Filter request bodies, authorization headers, and sensitive project identifiers before copying an error summary into logs. When tracing the call, record the request ID provided by the service, if any, the time sent, target model, and result stage. This lets an administrator investigate a particular authorization issue or gateway timeout without keeping the original request.
Set timeouts by stage, not just by increasing the overall limit
A connection timeout limits how long the client waits to establish a connection; a read timeout usually limits the wait between response data; and a total deadline limits how long a task can use resources. Names and semantics vary between client libraries, and some also have separate limits for waiting on a connection pool and sending a request. Read the documentation for the runtime you're actually using. Set limits based on how long users can wait, the service's maximum allowed duration, and the time needed to clean up the rest of the call chain. Don't copy parameter names or values from a different library.
For streaming reads, check the completion state too. After receiving each chunk, the parser should keep reading until it gets an explicit end signal or completes normally. If a read fails, mark the result as incomplete rather than presenting partial output as the final answer. Record user cancellations separately so the task can stop waiting and release resources. If an upstream gateway ends the request first, increasing the application's read timeout alone won't help; check how the time limits at each layer work together.
Set a retry budget and account for duplicate execution
For transient errors that the documentation says are retryable, use backoff with jitter. Follow any recommended wait time from the platform. Set an overall deadline and attempt limit, counting the initial request and retries against the same budget. If the client library retries automatically, don't blindly add another retry layer in the caller. Fix authentication or permission issues in the configuration; more requests won't make them disappear.
If a streaming request has already returned partial content, resubmitting it may produce a different answer, incur duplicate charges, or trigger downstream actions again. Don't append a new stream to the old text as if it were a continuation. Use an idempotency mechanism only if the platform explicitly supports it, and follow its documentation. Otherwise, check task status first or have the application workflow confirm whether resubmission is safe. Even for internal text tests, keep the original error and retry result separate so you can tell whether the failure was truly transient.
For comparisons of fixed exit IPs, concurrency, and timeout behavior, see the AI API route selection guide for developers. Whether a fixed exit IP is required depends on your organization's allowlisting or audit requirements; you can't infer that from a route name.
CLI, editor, and CI configuration
A command line, editor, and test process on the same computer may not inherit the same settings. Containers, remote workspaces, and CI runners have their own network boundaries. The correct configuration belongs on the side where the request is actually sent. First find out where the process runs, then check the network policy, certificate trust, and identity source used by that process.
Start by testing a regular connection from the CLI
Run the command below in the affected terminal to check whether it can reach a sample website. The destination has no account data, and the command requests only response headers; no credentials are used. Even if you get a response, that only shows this environment can reach the sample site. To test the actual product, run an authorized minimal test as described in its official documentation. The sample site and product may use different routes, access policies, and supported methods, so don't assume the result applies to the product.
curl --head --show-error https://example.com/
If the terminal is configured to use an organization-approved forwarding service, check that the client reads the relevant environment variables, that no rule excludes the destination from the proxy, and that the gateway address and port come from an approved configuration. Tools may interpret variable capitalization, wildcard patterns, and authentication settings differently. If both system settings and process variables are present, consult the tool's documentation to see which takes precedence. After changing settings, test in a new terminal to make sure you're checking a fresh process.
Check which certificate trust settings the failing process uses
If the browser works but a script reports an untrusted certificate, first identify which runtime is failing. Browsers, language runtimes, and container images may use different certificate trust stores. Check the system clock and request destination, and confirm whether the connection uses an organization-mandated forwarding service. If your organization requires a certificate, ask an administrator for the approved certificate and installation instructions. Don't disable verification just to make the test pass; that hides the fact that the destination's identity hasn't been confirmed.
After configuration, rerun a connection test without credentials in the same runtime, then make an application request with the minimum required permissions. If the app still fails, check whether startup arguments or application settings override certificate options in the request library it actually uses. Importing a certificate at the system level may not affect a process that's already running. Restart the service that sends the requests—not just the window displaying its interface.
For editor issues, distinguish local from remote execution
An editor launched from a graphical interface doesn't necessarily inherit the environment of an interactive terminal. Access from its integrated terminal doesn't mean extensions have access too. First identify which extension or built-in feature produced the error, then check its process in the diagnostics panel. In remote development, the editor UI is local, but extensions or helper processes may run on the remote machine; check them there in a compliant environment. Don't change system-wide network settings unconditionally to fix one plugin.
Test in an empty workspace to isolate repository configuration, enterprise policies, and project dependencies. Don't upload existing source files, and don't send a complete diagnostics bundle containing environment variables to a public support channel. If the issue goes away in an empty workspace, check whether the original workspace overrides proxy, model, or identity settings. Then ask the repository administrator whether that restriction is intentional. Don't change project-level policies to force a test without permission.
Run CI jobs with clearly defined permissions
In CI, first identify whether requests come from the host runner, a job container, or a separate service. Check which destinations the environment can access under organization policy, and use the CI platform's protected secret management to provide the required identity. Don't enable debug logs that print environment contents, and don't expose production credentials to untrusted pull requests. Keep connectivity checks separate from production calls: test with a least-privilege project, and reserve production calls for the designated workflow.
If only CI fails, compare its execution identity, trust source, name resolution path, and task time limits with your local environment—not just whether both have software with the same name installed. If an intermittent failure stalls the entire pipeline, set reasonable time limits and a clear failure state for the call before deciding whether to skip a non-critical step. Critical steps should fail explicitly, not publish partial results. After the issue is fixed, retest in the same job environment; a successful local command isn't a substitute for verification.
Rate limits, quotas, and restricted accounts
If you see “too many requests,” “account restricted,” or “insufficient permissions,” first check which system returned the error. The product may limit request rate, concurrency, processing volume, or budget; an enterprise gateway may also rate-limit traffic from the same source. An account review is a separate issue and may come with an in-product notification or a dedicated recovery process. These problems can all cause failed requests, but the same adjustment won't fix them all.
Use the error details to distinguish time-window limits from quotas
If requests are too frequent, errors may appear when many new tasks arrive in a short period. If a total quota or budget is exhausted, even a single request may continue to fail. Some platforms also distinguish request counts from input and output volume. Check current usage and limit scope in the project dashboard, and confirm the error refers to the project you're investigating. Treating every error as “try again later” may leave you blocked into the next work period.
Usage notices in a web product aren't the same as developer API quotas. Follow the web interface's guidance for browser use; for APIs, check the structured error and response headers for retry timing. If an internal gateway returned the error, ask an administrator to check its limits and counting method. If your organization shares a quota, your own request count doesn't show total organization usage. Ask whoever manages the project whether other apps are using the same resources.
Queue requests on the client side to prevent issues from escalating
Control concurrency before sending requests. It's best to put interactive and background jobs in separate queues based on business priority; background jobs shouldn't consume the connections and quota needed for interactive work. Mark tasks that have waited too long for later processing instead of starting them all and letting them fail simultaneously. When the app hits a rate limit, first slow incoming work and allow unneeded tasks to be cancelled. Then let valid queued tasks resume gradually, as the platform requires.
To see whether an adjustment is working, track pending task count, wait times, and error categories—there's no need to keep input text. If the success rate improves but waits get much longer, the pressure may simply have moved to the queue. Remove unnecessary input, combine genuinely duplicate tasks, or ask an administrator for an appropriate quota. Don't evade limits by rotating identities, sharing credentials, or changing exit IPs; that makes usage hard to attribute and may violate platform rules.
Use official channels first for account reviews
An account may be restricted because of a security incident, billing issue, organization license change, or policy enforcement. Don't assume from a similar forum post that the platform has banned your account. Check official notices, billing, and organization permissions first; determine whether the whole account is unavailable or only a specific feature, project, or workspace. If the platform confirms a manual review, stop unnecessary attempts and provide the information it requests through official channels. Don't pay for supposed account unblocking or verification services.
Tell support whether you recently changed work devices, organization permissions, or the calling program, or noticed unexpected usage. Focus on the timeline and verified facts, not guesses about what triggered the restriction. If multiple members are affected, have the organization administrator collect errors and request records centrally. Avoid duplicate reports, permission changes, or overwriting evidence. After an appeal succeeds, verify access with a permitted small task before returning to normal workload.
Choosing cross-border routes and retesting issues
VPNWhole offers 90+ countries / 180+ routes. Use the routes page to check coverage and route types; verify account details, usage, and pricing on the plans page. For AI tool connection comparisons, use only access methods permitted by the target platform and your organization's policies. Regions and route types can help narrow down tests, but don't guarantee a fixed exit IP, feature access, or reliability.
Choose a route based on what you need to test
When comparing IEPL, relay, and direct routes, test with the actual task instead of relying on route names. For web chat, check sign-in, time to first response, and whether the full conversation completes without interruption. For developer requests, use the same input in an authorized project and compare connection time, time to the first valid event, and task completion. If you need to receive files or images, test result downloads separately; don't combine throughput needs and interactive latency into a single metric.
Start by comparing routes in the same permitted region, then retest at different typical usage times. Keep the device, access network, account workspace, model, and input consistent. Wait for each task to finish before switching to another route. If the first run used a warmed-up session, use the same conditions for the next one; don't change routes while adding attachments. To understand what latency, packet loss, and bandwidth can each tell you, see How to test VPN speeds.
Use IP lookups to check the route, not to infer permissions
Use the exit IP lookup in your browser to see the exit IP for that browser connection and check whether it changed after switching routes. It reflects only the browser request that made the lookup, not a desktop editor, terminal, or remote runner. If the client routes traffic by app or destination, the lookup page and AI tool may also use different paths. To check a specific app, use its diagnostics or records approved by your administrator.
If the reported exit region differs from what you expected, don't draw conclusions from a single label. Check the selected connection, other forwarding settings, and whether you just switched back from another network, then ask the relevant support team to investigate. If the network is stable but the platform explicitly rejects your region or organization identity, check the platform's availability information. Changing routes won't solve a permissions issue. If your work environment requires a registered exit IP, get approval from your administrator rather than treating a single lookup as authorization.
Record a baseline and keep reproducible comparison results
Focus your notes on “conditions, stage, and result”: the device and runtime, the product feature, and whether the issue happened during sign-in, before the first response, mid-stream, or after completion. Note whether the same task worked on an alternative compliant network. If the issue persists across routes and devices, check platform status notices and investigate the account or project. If it happens only on your home connection and affects multiple apps, first check local Wi-Fi and the access link, then contact route support.
One successful retest doesn't prove the issue is fixed. Repeat the input and work environment that triggered the problem, and confirm that the task completes. If you mainly use the service in the evening, test again then. If the task works only after switching models, record that as a usable alternative configuration; don't mark the original model issue as resolved. When results are inconclusive, preserve reproducible conditions instead of writing “works sometimes” to make the next investigation easier.
Send the report to the team responsible
For VPNWhole client, subscription, or route issues, find support through the Contact page or describe your retest in a support ticket in the user dashboard. Contact the relevant platform or organization administrator about account permissions, model quotas, and task status. Before submitting, remove subscription URLs, account credentials, and request bodies. Include only the necessary failure stage, a redacted error, and your retest results.
If you traced the issue to local installation, system permissions, or subscription import, there's no need to change your platform account. Return to the Guides and recheck the steps for your system. Once connected, verify it with a short task from this guide. If only one AI product entry point is affected, return to Tool-specific requirements and check its permissions and task stage. That lets you continue from the last confirmed step instead of repeating the entire troubleshooting process.