OpenAI ne prend officiellement pas en charge des dizaines de pays — y compris la Russie, la Biélorussie, l'Iran et plusieurs autres régions.
En essayant de lancer codex
depuis ces emplacements, vous obtiendrez soit un blocage direct par géolocalisation, soit un refus de délivrance de clé API,
soit une connexion instable avec des interruptions constantes lors de l'exécution de tâches cloud. Cela peut être résolu par
un serveur proxy correctement sélectionné et configuré — mais ici, les nuances sont importantes : tous les types de proxy
ne conviennent pas aux outils CLI et aux processus de fond prolongés.
Pourquoi Codex est bloqué dans votre pays
OpenAI applique des géoblocages à plusieurs niveaux simultanément. Tout d'abord, l'adresse IP est vérifiée
à chaque requête à l'API — si elle appartient à un pays de la liste des pays non pris en charge, le serveur renverra
une erreur 403 Country, region, or territory not supported.
Deuxièmement, lors de l'inscription d'un compte et de l'association d'une carte de paiement, le système vérifie la géolocalisation de l'IP,
l'adresse de facturation de la carte et le fuseau horaire de l'appareil — des divergences augmentent le risque de blocage du compte.
Troisièmement, même après une inscription réussie, les sessions CLI peuvent être interrompues si l'IP change soudainement
de géolocalisation en plein milieu d'une tâche — cela est typique pour les IP dynamiques des opérateurs mobiles ou
lors de l'utilisation de VPN gratuits avec un pool d'adresses instable.
Pour les développeurs qui utilisent Codex CLI en lien avec l'automatisation — écriture de code, révision des pull requests, génération de tests dans un pipeline CI — toute interruption de connexion signifie une tâche échouée en plein milieu de son exécution. Il est donc important de ne pas simplement "contourner le blocage", mais d'assurer une IP stable avec la bonne géolocalisation pendant toute la durée de l'opération.
Quel type de proxy est nécessaire pour Codex CLI
Pour travailler avec l'API OpenAI et les outils CLI qui en découlent, trois paramètres sont critiques : la stabilité de la session (l'IP ne doit pas changer en plein milieu de la requête), la vitesse de réponse et la propreté de la réputation de l'adresse (n'est-elle pas sur les listes noires des services d'abus). Examinons les options :
| Type de proxy | Pour Codex CLI | Stabilité de la session | Vitesse |
|---|---|---|---|
| Proxys résidentiels | Oui, choix principal | Élevée (sessions sticky) | Moyenne-élevée |
| Proxys de centre de données | Convient pour CI/CD et le scraping | Très élevée (IP fixe) | Maximale |
| Proxys mobiles | Superflu pour les tâches API | Moyenne (rotation de l'opérateur) | Moyenne |
Pour la plupart des scénarios — développement local, CLI personnel, requêtes API irrégulières — les proxys résidentiels avec une IP assignée par session (sticky session) sont les mieux adaptés. Ils fournissent de vraies IP de fournisseurs domestiques dans le pays choisi, ce qui réduit le risque d'être soumis aux filtres de détection d'abus d'OpenAI. Si Codex est lancé dans un pipeline cloud avec un grand nombre de tâches parallèles — par exemple, révision automatique de dizaines de dépôts — il est plus avantageux d'utiliser des proxys de centre de données : ils sont plus rapides et plus stables pour maintenir de longues connexions sans fluctuations de latence.
Configuration du proxy dans Codex CLI via des variables d'environnement
Codex CLI, comme la plupart des outils modernes Node.js et Python, respecte les variables d'environnement standard
HTTP_PROXY
et HTTPS_PROXY.
C'est le moyen le plus simple de faire passer tout le trafic CLI par le proxy sans modifier les configs de l'application.
# Linux / macOS (bash, zsh)
export HTTP_PROXY="http://login:password@proxy_host:port"
export HTTPS_PROXY="http://login:password@proxy_host:port"
export NO_PROXY="localhost,127.0.0.1"
# Vérification avant le lancement de Codex
curl -x $HTTPS_PROXY https://api.openai.com/v1/models
# Lancement du CLI
codex "écris un test unitaire pour la fonction validateEmail"
# Windows PowerShell
$env:HTTP_PROXY = "http://login:password@proxy_host:port"
$env:HTTPS_PROXY = "http://login:password@proxy_host:port"
# Vérification de la connexion
Invoke-WebRequest -Uri "https://api.openai.com/v1/models" -Proxy $env:HTTPS_PROXY
codex "refactorise ce module"
Si le proxy nécessite une authentification par login et mot de passe (la plupart des fournisseurs fonctionnent ainsi),
indiquez-les directement dans l'URL du proxy au format
http://user:pass@host:port.
Pour les proxys SOCKS5, utilisez le protocole socks5://
au lieu de http:// —
c'est important, car certains outils CLI distinguent les protocoles et peuvent ignorer un schéma incorrectement
spécifié.
Proxy via fichier de configuration et wrappers Python
Si vous écrivez vos propres scripts autour de l'API OpenAI (par exemple, traitement par lots de tâches via
openai-python
SDK), les variables d'environnement peuvent ne pas suffire — il est parfois plus pratique de transmettre explicitement le proxy au client.
import httpx
from openai import OpenAI
proxy_url = "http://login:password@proxy_host:port"
client = OpenAI(
api_key="sk-...",
http_client=httpx.Client(proxies=proxy_url, timeout=60.0)
)
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Génère une migration de base de données"}]
)
print(response.choices[0].message.content)
Pour les wrappers Node.js (si votre pipeline Codex est construit sur JS), la logique est similaire via
https-proxy-agent :
const { HttpsProxyAgent } = require('https-proxy-agent');
const OpenAI = require('openai');
const agent = new HttpsProxyAgent('http://login:password@proxy_host:port');
const client = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
httpAgent: agent,
});
const run = async () => {
const res = await client.chat.completions.create({
model: 'gpt-4o',
messages: [{ role: 'user', content: 'Vérifie le code pour des vulnérabilités' }],
});
console.log(res.choices[0].message.content);
};
run();
La transmission explicite du proxy dans le code est utile lorsque certaines requêtes dans votre application doivent passer directement (services internes), tandis que d'autres doivent passer par un proxy (requêtes vers OpenAI). Ainsi, vous ne cassez pas la logique réseau restante de l'application avec des variables d'environnement globales.
Proxy pour les tâches cloud : Docker, CI/CD, GitHub Actions
Si Codex est utilisé non localement, mais dans un pipeline automatisé — révision de code à chaque pull request, génération nocturne de documentation, refactorisation automatique — le proxy doit être spécifié au niveau de l'environnement d'exécution de la tâche, et pas seulement dans le terminal du développeur.
# Dockerfile
FROM node:20-slim
ENV HTTP_PROXY="http://login:password@proxy_host:port"
ENV HTTPS_PROXY="http://login:password@proxy_host:port"
ENV NO_PROXY="localhost,127.0.0.1"
RUN npm install -g @openai/codex
WORKDIR /app
COPY . .
CMD ["codex", "run", "review"]
# .github/workflows/codex-review.yml
name: Codex Review
on: [pull_request]
jobs:
review:
runs-on: ubuntu-latest
env:
HTTPS_PROXY: ${{ secrets.PROXY_URL }}
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
steps:
- uses: actions/checkout@v4
- name: Installer Codex
run: npm install -g @openai/codex
- name: Exécuter la révision Codex
run: codex review --diff origin/main
Pour CI/CD, un IP statique fixe est préférable — c'est justement le scénario où les proxys de centre de données se montrent meilleurs que les résidentiels : la latence est plus basse, la connexion ne se coupe pas lors de longues tâches, et le coût du trafic lors de gros volumes de requêtes est sensiblement plus bas. Assurez-vous de stocker les secrets du proxy (login, mot de passe, hôte) dans les Secrets du dépôt, et non dans le fichier workflow lui-même.
Rotation IP et stabilité des longues sessions
La principale erreur lors de l'utilisation de Codex via un proxy est d'utiliser une IP avec une rotation automatique à chaque requête dans le cadre d'une tâche multi-étapes. L'API OpenAI prend en charge des réponses en streaming longues et des appels consécutifs dans un même contexte — si l'IP sortante change entre ces appels, le service peut considérer cela comme une activité suspecte ou simplement rompre la connexion de streaming.
La solution est des sessions sticky : le proxy maintient la même IP attachée à votre connexion pendant une période donnée (généralement de 1 à 30 minutes, selon les paramètres du fournisseur), après quoi il la change pour une nouvelle. Pour Codex CLI, il est optimal de définir la durée de la session à au moins la durée de votre tâche la plus longue — si la génération d'un grand PR prend 5 minutes, la session doit durer au moins 10-15 minutes avec une marge.
# Exemple de formation d'une session sticky via un paramètre dans le login du proxy
# (la syntaxe dépend du fournisseur, l'option typique ci-dessous)
export HTTPS_PROXY="http://user-session-abc123:password@proxy_host:port"
Si les tâches sont lancées en parallèle dans CI (par exemple, révision de 10 pull requests en même temps), chaque job parallèle doit se voir attribuer un ID de session distinct — ainsi, vous évitez la situation où plusieurs processus "tirent" simultanément la même IP et atteignent la limite de taux de l'API trop tôt.
Erreurs fréquentes et comment les corriger
Examinons les problèmes typiques auxquels les développeurs sont confrontés lors de la configuration des proxys pour Codex CLI et l'API OpenAI.
| Erreur | Cause | Solution |
|---|---|---|
403 unsupported_country_region_territory |
Le proxy n'a pas été pris en compte, la requête est partie avec l'IP réelle | Vérifiez les variables d'environnement via curl -x |
| Le stream se coupe au milieu de la réponse | L'IP a changé en plein milieu de la session (pas de mode sticky) | Activer la session sticky, augmenter la durée de vie de l'IP |
| Timeout / connexion refusée | Port ou protocole incorrect (http au lieu de socks5) | Vérifiez le protocole et le port dans la documentation du fournisseur de proxy |
| La limite de taux est atteinte trop rapidement | Plusieurs processus utilisent la même IP simultanément | Attribuer des IDs de session distincts à chaque processus parallèle |
| Le compte a reçu un avertissement d'activité suspecte | L'IP du centre de données a été ajoutée à la base d'abus | Passer à une IP résidentielle avec une bonne réputation |
Liste de contrôle avant le lancement
Avant de confier une tâche de production à Codex CLI via un proxy, passez en revue cette courte liste :
- Vérifié l'accessibilité de
api.openai.comviacurl -xavec votre proxy - La géolocalisation du proxy correspond au pays indiqué dans la facturation du compte OpenAI
- Session sticky activée avec une durée de vie supérieure à celle de la tâche la plus longue
- Pour CI/CD, les secrets du proxy sont stockés dans Secrets et non dans le code du workflow
- Pour les tâches parallèles, différents IDs de session sont utilisés, et non une seule IP partagée
- Les logs CLI ont été vérifiés pour des requêtes directes cachées contournant le proxy (par exemple, provenant de dépendances tierces)
Conclusion
Travailler avec OpenAI Codex CLI depuis un pays sans support officiel nécessite non pas un contournement ponctuel du blocage, mais une configuration systématique du réseau : le bon type de proxy, des sessions sticky pour les requêtes longues et une intégration soignée dans les variables d'environnement ou le code client. Pour le développement local et les tâches irrégulières, les IP résidentielles avec une bonne réputation sont préférables, tandis que pour les pipelines CI/CD chargés — des proxys de centre de données rapides et stables.
Si vous prévoyez d'exécuter Codex et d'autres outils basés sur l'API OpenAI depuis une région sans support officiel, nous vous recommandons de commencer par des proxys résidentiels pour un fonctionnement stable du CLI, et pour des tâches automatisées à grande échelle dans le cloud — avec des proxys de centre de données, qui garantiront une faible latence et un coût prévisible lors de gros volumes de requêtes à l'API.