Networking · Reference Guide

AI Connection Guide

If you haven’t installed a client or imported your subscription yet, start with the Guides, then come back to check the connection for a specific tool. The quickstart shows you how to connect; this guide helps you pinpoint issues after you’re connected.

A webpage loading doesn’t mean your account can use a particular model. And a working browser chat doesn’t mean your terminal or build job uses the same network path. Identify where the failure occurs before deciding whether to check connectivity, review permissions, or wait for the service to recover.

What happens along an AI request path

Start with the last step that succeeded

A web chat may load the page shell, restore your sign-in session, retrieve the workspace and available models, then submit your message and receive a response. The page shell may load from cache or a static asset service, so seeing the input box only means part of the interface is available. If it spins after you send a message, the request may not have been sent—or the service may have received it but not started responding. Don’t just note that it “won’t open.” Record whether it stopped at a blank page, a sign-in redirect, workspace loading, message submission, the first response segment, or completion. The last successful step is more useful for narrowing things down than a full account of every setting.

Start with a short request that contains no business-sensitive information. Check whether the first response segment arrives and whether the request completes. Then compare it with a representative, non-sensitive example of your usual length. If short requests work but longer tasks keep getting interrupted, focus on connectivity and timeouts during output. If even the workspace list won’t load, start with the sign-in session and page requests. Test attachments separately: if text sends but attachments fail, check format and size requirements before changing your network settings. Keep input, attachments, and output in separate notes, since they may use different endpoints.

Tell connection failures, service denials, and frontend errors apart

DNS resolution, connection setup, and the TLS handshake all happen before a request can proceed. If the browser explicitly reports that it can’t find the host, the connection failed, or the certificate isn’t trusted, first check your local network, system clock, trusted certificate settings, and organizational gateway policies. If you’ve received a permission error from a service, at least one response reached your client. Next, identify whether it came from the official service, a corporate gateway, or the application’s own proxy layer. Don’t lump every error page together as a dropped connection, and never disable certificate verification just to make a warning disappear. Ask your administrator to confirm and configure certificate or proxy exceptions for corporate networks.

When using browser developer tools to inspect requests you initiated, first find the one that matches the time of the failed action. Note its category, any status code that’s safe to share, and a brief error summary. Determine whether it was a main page, sign-in callback, attachment, or streaming request. Page scripts can also fail while parsing a successful response, so a success status alone doesn’t prove the action completed. Conversely, an ad blocker stopping an analytics request may not affect the conversation. Instead of sending support a screen full of red log entries, identify the failed user action, the first related request to fail, and what the interface showed next.

Know the limits of region checks and connection stability

AI platforms may use your access location, account details, workspace policies, and product eligibility to determine whether a feature is available. A new device, expired session, or sudden change in access environment may also prompt extra verification. Platforms rarely disclose their full risk checks, so one failed sign-in doesn’t prove an exit IP has been blocked. Check the product’s official supported regions and eligibility requirements, then follow the platform’s verification prompts. Changing routes won’t change your account details, billing country, or organization permissions, and shouldn’t be used to evade regional restrictions or verification requirements. If the product explicitly says your current environment isn’t supported, stop trying and check the official guidance.

Long-lived connections need to be evaluated separately. Some intermediary devices close connections after a period without data; some gateways buffer output and deliver it all at once. You might see text that doesn’t move for a while, then appears in a burst, or a response that disappears halfway through. A regular webpage or file download can show whether a single transfer completes, but it can’t substitute for observing a streaming session. During troubleshooting, note how long the first segment takes, when output pauses, and how the request ends. Don’t diagnose a particular segment based on one speed test or how quickly the main page loads.

Where to start troubleshooting different AI tools

Write down the full product name before investigating a feature. A single provider’s web app, developer console, organization workspace, and integration plugins may use different permissions and settings. The table below suggests where to start; it isn’t a regional availability list and doesn’t guarantee that every feature is enabled for every account. Check the platform’s official guidance and your current account interface for regional availability, product eligibility, and available models.

ToolFirst place to checkWhat to distinguish when troubleshooting
ChatGPTWeb chat and developer platformWeb session, workspace, and API project
ClaudeWeb workspace and API consoleAccount eligibility, model access, and interrupted output
GeminiChat interface, developer portal, and cloud projectProduct eligibility, organization policies, and project settings
CopilotSpecific product and sign-in identityPersonal account, organization license, or editor entitlement
MidjourneyThe web or Discord interface you’re actually usingTask submission, generation status, and media loading
CursorEditor session and selected modelApp sign-in, model requests, and workspace context

ChatGPT and Claude: Check the session separately from generation

If you can sign in but errors begin after switching workspaces, first confirm that you’re in the right workspace and that its administrator has enabled the feature. In a blank session, send a short, non-sensitive text prompt without attachments or extra tools. If a new session works but an old one doesn’t, compare context length, attachments, and tools. If all sessions fail, check service status, account notices, and client errors. Don’t copy material from an old conversation to an unapproved platform for testing—especially team documents, customer conversations, or internal code.

Check web subscriptions and API projects separately. Being able to use a model in a browser doesn’t mean your API credentials belong to a project authorized to call it. Developers should check the project, model, and billing status in the relevant console rather than relying on the web account’s plan name. If a colleague can make calls but your credentials fail, compare project ownership, roles, and the model in use instead of exchanging credentials. This helps determine whether the difference is due to personal permissions, project settings, or the application’s deployment environment.

Gemini and Copilot: Verify your identity, then check organization access

Gemini’s personal chat, developer portal, and organization cloud project are separate environments. When a browser is signed in to multiple identities, a page may keep using the previously selected organization. Check the account, project, and administrator notices shown in the interface, then consult the product documentation for regional, project, and model requirements. Switching networks can’t replace an administrator’s setup if the project hasn’t enabled the required feature. If a public page opens but you can’t get into the intended workspace, report the issue to an administrator who can check your identity and access.

Be specific about which Copilot you mean. The web interface and GitHub Copilot in an editor shouldn’t share the same troubleshooting assumptions. If the editor starts and the repository is accessible, that only confirms that the editor and repository service are working—not that the completion service is authorized. Check the identity signed in to the extension, product access, and interface status. If completions work but chat doesn’t, record each action and its error separately. When reporting an issue to your organization’s support team, name the application and feature instead of saying only that “Copilot won’t connect.”

Midjourney and Cursor: Separate background tasks from local display

Task submission, background generation, and image display are separate stages in Midjourney. If a task is listed but its preview won’t load, check the task status and media request before submitting it again. If you use Discord, also confirm that your identity and the current space allow the action. A task that wasn’t created, a background generation failure, and a generated result that won’t open locally each call for different checks: command or interface feedback, service status, and media loading. For more detail on these steps, see the Midjourney and Discord connectivity guide.

In Cursor, start with a short conversation in an empty workspace you’re authorized to use. If it works in an empty workspace but fails in a large project, check for large file attachments, whether indexing has finished, and any context-related message from the selected model. Treat the editor’s sign-in session and scripts running in its integrated terminal as separate environments. Don’t paste your full source code into a prompt just to troubleshoot. Use synthetic text to test the feature, then handle real project data as your organization permits once you’ve identified the failing stage.

Account setup, sign-in redirects, and session checks

Keep your network subscription and AI platform accounts separate

5HVPN doesn’t require an email address; you can create an account with a username and password. This applies only to our service. Third-party AI platforms set their own account requirements, verification steps, billing, and workspace permissions. Before you start, check the product’s official page to confirm it’s available for your region and account type. Team users should also check that their administrator has approved it. Don’t reuse passwords across services, and never enter full credentials in third-party tutorials, scripts, or chat windows. Organization accounts should be set up through the designated organizational entry point, not mistaken for personal sessions.

Before signing in for the first time, you can make a note that contains no secrets: which official entry point to use, which workspace you expect to access, and whether an organization administrator’s approval is needed. After signing in, check the identity and workspace shown on the page. If an organization invitation opens a personal space, that doesn’t mean you’ve accepted the invitation. And switching to an organization space doesn’t mean you’re licensed for every tool. If you’ll configure a developer project next, note its owner and check it against the console when you make calls. Route billing, identity, and network issues to the people who can handle them.

Sign-in loops: Check that conditions match before and after the redirect

A typical single sign-on flow takes you from an app to an identity provider and back, where the app processes the callback and establishes a session. If the sign-in page says it succeeded but you end up back where you started, the required cookies may be blocked, a browser extension may have modified the request, or the entry point and return URL may not be paired correctly. Start over from the official entry point and complete the flow in the same browser window. Don’t copy a URL containing temporary parameters to another device or click through verification in multiple tabs at once. Avoid switching networks and browsers during sign-in, or it’ll be hard to tell one attempt from another.

If the loop continues, note whether the identity provider reports an error or one appears only after you return to the app. Compare using a clean browser profile to see whether extensions, tracking protection, or an existing session affect the site. Private browsing may use different cookie policies, so it isn’t always a reliable final test. Make the smallest necessary change for the affected site; don’t clear data for every site or loosen global permissions. If a personal account works but an organization account doesn’t, check the organization’s sign-in policies, app access, and administrator notices. Don’t treat network routing as a way to override organization policies.

Additional verification, account restrictions, and secure recovery

If you see a verification prompt, keep its full text and the time it appeared, then follow the official process. Repeatedly requesting codes or opening multiple windows to try again may invalidate an earlier attempt and make the issue seem intermittent. If you see an explicit restriction, suspension, or unsupported-region notice, stop retrying, check official notices, and use the appeal or support channel. Don’t use someone else’s account as a substitute or rely on repeatedly changing exit routes to restore access. Even if an action succeeds once, that doesn’t prove the account restriction has been lifted; use the platform’s stated account status.

If you suspect credentials have been exposed, first revoke the relevant sessions or keys through the platform, then reset affected sign-in credentials and review the account activity available to you. For a team account or project, notify an administrator to check access records and permission changes. Before sharing screenshots, hide account identifiers, invitation links, redirect parameters, and sensitive workspace information. Never send support your password, session cookies, or full authentication headers. A note with just the entry point, error category, time, and last successful action is usually safer and easier to review than an unredacted screen recording.

API requests, timeouts, and streaming output

Start with a minimal request you can repeat

Web apps typically handle sign-in, connection recovery, and error display behind the interface. With API calls, your application must manage authentication, projects, models, timeouts, and retries. Get the request format from the official documentation, then send a short text request from an authorized project without attachments, tool calls, or a large conversation history. Start by verifying a non-streaming response. Record the service endpoint, project owner, and model name, but never the key. Once the minimal request works, add streaming, typical input, and concurrency back one at a time. If an error appears only after adding one, focus on that change and its related settings.

When a service returns a structured error, read its category and details before deciding what to do next. Fix the request for a parameter validation error; check the source of the credentials for an authentication error; and check project roles or product eligibility for a permission denial. Blind retries usually won’t help with these issues. If the response came from an intermediary gateway, identify whether your application received the official format or a page rewritten by the gateway. Developers can refer to Choosing a connection for AI API calls when evaluating routes. Network access doesn’t grant model permissions or guarantee remaining quota.

Set separate limits for connecting, waiting for data, and completing the task

What to observeStageWhat to check
Connection timeoutConnection setup and handshakeDNS, proxy, certificates, and routing
Time to first byteFrom request sent to first response segmentService queue, input processing, and client timeout
Idle timeoutInterval between streaming dataGateway idle limits, buffering, and disconnects
Overall deadlineFrom starting the operation to completionTask budget, cancellation, and retry overhead

“Read timeout” doesn’t mean exactly the same thing in every client: some measure idle time between data chunks, while others count reading as part of the entire call. Don’t assume a parameter name from one SDK applies to another. Check when the application, SDK, reverse proxy, and upstream service can each terminate the request. Extending only the outer call won’t help if an internal gateway cuts the connection first. Don’t reset the overall deadline with every retry, or an interaction that appears to allow a reasonable wait may build up a large number of unfinished requests. Be explicit about what cancels the request and whether cancellation reaches the client doing the work.

Check whether the stream completed, not just whether it responded

A success status and a chunk of text don’t prove a streaming task is complete. If the API uses server-sent events, follow its documentation to parse event boundaries and completion signals. A single underlying read may contain part of an event or several events, so don’t treat each read as one complete message. Your application should distinguish content chunks, tool events, and error events, and mark success only after receiving the documented completion status. When using an SDK, handle exceptions that occur during iteration—not just when creating the request. Then, if a user sees a partial answer, the interface can accurately report that the stream was interrupted.

If you operate your own application proxy, compare when the proxy and the authorized upstream each receive the first data. Check whether the gateway compresses, aggregates, or buffers events and whether the browser waits until the connection closes before rendering. If the stream drops after output begins, don’t append a resubmitted response to the old one. The background task may have generated a different result, and duplicate requests can incur costs or cause side effects. Save any output received and mark it incomplete. Resume or retry only if the product explicitly supports it or your application has safeguards for duplicate calls.

Finally, distinguish “request failed to send” from “no result received.” By the time a local timeout occurs, the upstream task may already have started or even completed. For write operations, generation tasks, or paid requests, first check the status using a platform-supported request ID or task lookup. If the API supports idempotency, confirm which operations it applies to and its scope. Otherwise, keep a task record in the application and let the user decide whether to try again. Don’t enable independent, overlapping automatic retries in the SDK, background queue, and browser.

Network settings for the CLI, IDE, and CI

Find the process that actually makes the request

Browsers, desktop apps, and terminals may read different proxy settings. An IDE extension host may also run on a different machine from its integrated terminal. First determine whether the request comes from your local machine, a remote development host, a container, or a build runner. Then check network and certificate settings in that environment. If the IDE shows a remote workspace, don’t assume extensions share the editor’s local network. Some extensions run locally; others run with the workspace. Check the extension documentation and diagnostics to find out which. Once you’ve identified the runtime environment, compare whether the problem occurs only with a particular launch method.

In the same terminal session, check that network probes and application calls are running in the expected environment. The commands below use a public example domain, send no authentication details, and print only a brief summary of connection and response timings. The first command won’t print the proxy address or its value either. These commands are for environments with a POSIX-style shell and curl. Reaching a public example site shows only that this probe succeeded; it doesn’t prove an AI service allows your account or that the target application reads the same settings.

for name in HTTP_PROXY HTTPS_PROXY NO_PROXY http_proxy https_proxy no_proxy; do
  if printenv "$name" >/dev/null; then
    printf '%s is set\n' "$name"
  fi
done
curl --silent --show-error --output /dev/null \
  --write-out 'HTTP=%{http_code} DNS=%{time_namelookup} CONNECT=%{time_connect} TLS=%{time_appconnect} FIRST=%{time_starttransfer} TOTAL=%{time_total}\n' \
  https://example.com/

These timings are checkpoints measured from the start of the request, not separate durations for each stage. When using a proxy, the connection timing may refer only to the proxy connection, and incomplete stages may have no meaningful reading. Don’t treat a single timing as the target service’s latency. To test the actual tool, send an authorized minimal request from the same environment, following the service documentation. Don’t turn on verbose headers during a probe and then post the terminal log in a public forum.

Pass settings only to the processes that need them

Some clients read proxy environment variables, some use only their own settings, and clients vary in their support for uppercase and lowercase names. Check what your client actually reads in its documentation; the presence of a variable in your terminal doesn’t mean a plugin uses it too. For exclusions, list only internal domains that are approved for direct access. How empty values, wildcards, and domain suffixes are interpreted depends on the client. Verify settings in the current process before adding them to project configuration. Don’t put proxy settings containing credentials in a project repository, a shared copy of a shell startup script, or a public troubleshooting checklist.

When you launch an editor from a graphical interface, the extension host may not inherit environment variables you just set in a terminal. After changing settings, reload the affected window or extension host as the editor documentation recommends, and confirm that it’s still connected to the intended workspace. If your company network requires an organization-trusted certificate, add it to the correct trust store using an administrator-approved configuration. Some runtimes use a separate trust store, so a successful system browser test doesn’t prove the runtime trusts the certificate. Don’t disable verification to work around a development build problem; that setting can easily end up in a shared environment.

CI: Manage execution location, credentials, and concurrency separately

A CI runner may have different egress, permissions, and environment variables from your development machine. If a repository works on a personal branch but fails in a merge job, first check whether the workflow trigger is allowed to read project secrets, then confirm the runner can access the target service. Inject secrets through the build platform’s secret manager and grant them only to jobs that need them. Builds triggered by external contributions shouldn’t automatically receive production credentials. For troubleshooting, record whether a variable is present or which environment owns the credential—never its value. If the environment requires approval, don’t disable that approval or put production credentials in a test command just to check connectivity.

A successful one-off request from a development machine doesn’t guarantee that the pipeline will succeed when multiple jobs start at once. Put concurrency controls at the queue or execution layer that can see shared resources. Set a clear time budget for external requests and distinguish transient errors that are safe to retry from configuration errors that need manual fixes. Validate parsing, templates, and archiving offline with redacted samples or mocked responses wherever possible. Reserve real calls for authorized integration tests with traceable results. That way, if an external service is temporarily unavailable, you can see which step was affected instead of labeling the whole pipeline as a network problem.

Compare routes against your workload

Define what “stable” means for your task

Writing conversations, code completion, image tasks, and batch API calls have different network needs. Short chats are more sensitive to time to first byte; long generations depend on uninterrupted output; image tasks need submission and media download checked separately; batch jobs need to account for timeouts and retries piling up when requests run together. List your most common actions and the consequences of failure before comparing routes. If you mainly use a web app, one terminal speed test can’t tell you whether a browser session will drop during a long conversation. If you mainly run builds, a working desktop connection can’t speak for the runner.

Compare only within the product’s supported and your organization’s permitted scope. Record a baseline with your current settings, then repeat the same action over another approved connection path. Keep the device, identity, model, sample input, and task type the same; change only the condition you’re testing. Use non-sensitive short text and representative long output to see whether the response completes, and an approved test attachment to check uploads and downloads. Don’t switch paths midway through sign-in verification. To compare generation, finish signing in and confirm the workspace first, then start the test.

What route types can—and can’t—tell you

Route typeWhat it meansWhat to look for
IEPL dedicated routeThe route is labeled as including a dedicated transmission segmentOutput pauses and completion during your usual hours
RelayedTraffic reaches the exit through an intermediate relayWhether a connection can be established and when interruptions occur
DirectThe client reaches the selected exit without that relayHow each local access network performs

Dedicated, relayed, and direct describe transmission paths, not authentication markers for an AI platform. Even with a dedicated segment, the connection between your device and the access point, the route from the exit to the target service, and the target service itself can all affect performance. Whether a relay is suitable depends on the actual ingress and egress paths; a direct connection doesn’t necessarily mean a shorter physical route. When viewing 5HVPN routes, use region and type as filters, then test with the tools you use regularly. 5HVPN covers 100+ countries and 220+ routes. These are service coverage figures, not a list of regions where third-party tools are available.

If a team project restricts access by origin, ask the project administrator to confirm approved exits and connection methods first. A regular route’s name, region, or connection status doesn’t prove that its address is dedicated, fixed long term, or approved by your organization. For workflows that require a fixed exit, an administrator should verify address allocation and change procedures, and establish a formal update process. Don’t change your region details, bypass access rules, or treat one successful response as proof that an address is fixed. If an organization project fails only after you change connections, check the access policy with your administrator rather than weakening production security settings to accommodate a temporary connection.

Turn test results into everyday settings

Keep a brief comparison log: when you tested, which environment and route type you used, what action you performed, whether the first response segment arrived, and whether it completed. If a test coincided with an incident in a service notice, mark it as affected by that incident instead of using it to judge the route. If results change noticeably when the same device switches access networks, keep checking local access and system settings. If different environments show the same permission error in one workspace, focus on platform and organization settings. Confirm recurring evening interruptions with repeatable comparisons; don’t judge the whole route based on a single reconnect.

When choosing a plan, consider device and data usage, but don’t confuse a plan tier with model access. 5HVPN supports unlimited simultaneous devices and works with Windows / macOS / iOS / Android / Linux. Everyday text use differs from frequent attachment transfers, generated image downloads, or development testing. Review your own usage, then compare monthly subscriptions and data plans on the pricing page. Network service specifications and third-party platforms’ subscriptions and usage limits are separate; check each to see what needs adjusting.

Rate limits, account restrictions, and recovery

First identify who imposed the limit

The same “too many requests” message may mean your application’s gateway rejected a queued task, or that an AI service limited calls by project, model, or another dimension. Check the structured error body, client logs, and official console to identify who returned the error and what it applies to. Request rate, concurrency, input and output limits, and billing balance are different constraints. Shortening an input might help with an oversized context, but won’t necessarily fix a balance or concurrency issue; changing routes won’t increase project quota. If someone manages a shared project, first check whether other jobs are using its quota, then decide where to reduce request pressure.

For temporary limits that explicitly allow retries, follow the service’s recommended wait time. If none is given, use backoff with jitter and set a finite retry budget for the entire operation. With multiple parallel jobs, don’t let every task retry rapidly on its own; a brief slowdown can turn into a sustained request spike. Pause new batch tasks or lower concurrency, and tell users of interactive tasks whether they’re delayed or have failed. If the error says access has expired, quota is exhausted, or billing needs attention, stop automatic retries, preserve relevant diagnostic details, and contact the project owner.

An account restriction isn’t an ordinary connection drop

Platforms may restrict an account because of unusual sign-ins, exposed credentials, policy violations, or billing issues. Refer to the official notice for the specific reason. A brief loss of network connectivity doesn’t prove an account is restricted; if the interface explicitly requires verification or says the account is suspended, don’t dismiss it as a network fluctuation. Check the official console or appeal channel, gather relevant sign-in and project changes from before and after the issue, then follow the support process. Notify the administrator for a team account. Don’t repeatedly create accounts, borrow someone else’s credentials, or try to offset a restriction by cycling through entry points; that won’t fix the original account and will make troubleshooting harder.

To reduce everyday risk, use platform-approved identities for personal accounts and automation projects, and limit access to workspaces and models according to each role. Keep project keys separate by environment and revoke them promptly when someone leaves, changes roles, or may have exposed a key. Before enabling a new integration, review which files and logs it sends and grant only the necessary access. If you suspect a leak, pause affected automation and notify the owner. After rotating credentials, verify recovery with a minimal request; don’t leave old credentials in background processes to keep failing. Confirm account recovery, restored permissions, and restarted tasks separately—a working web sign-in alone isn’t enough.

Create a redacted handoff note

Write a concise, repeatable timeline: when and in which environment you acted, the last step that succeeded, what appeared when it failed, the one condition you changed, and the result. If the API provides a request ID that can be shared with official support, include it, but leave out request bodies, full headers, and sensitive workspace data. For a dropped stream, note whether the first segment and completion event arrived and how the interface marked the task. For sign-in issues, say whether the identity provider returned an error or the app failed after the redirect. Don’t include a full URL containing temporary parameters.

Send the note to the people responsible for the relevant part of the system: the official AI platform can check accounts, models, projects, and service status; your organization administrator can check licenses, certificates, and network policies; the 5HVPN Help Center can help with client and connection issues. If the problem began while importing or updating a subscription, follow the subscription link setup guide to check the import steps. If you suspect a subscription link has been exposed, follow the guide’s steps and don’t share the real link. For network issues, report your operating system, the route type shown by your client, and the symptoms. Don’t provide third-party platform credentials.

After recovery, first repeat the minimal action that failed, then return to your real workload. If a change fixed the issue, keep the effective change and remove temporary permissions, logging switches, and test settings added during troubleshooting. If the cause is still unknown, mark which stages are confirmed and which aren’t for comparison next time. Keep unfinished background tasks separate from completed results to avoid submitting them again during recovery. Troubleshooting is complete only when you can reconnect, know the status of old tasks, and know where to start if the same issue happens again.