# Eigene API-IP entfernen `POST /account/api/v1/proxies/authorized-ips/remove` ## Autorisierung `Authorization: Bearer YOUR_ARNPROXY_API_KEY` `Accept: application/json` Erforderliche Berechtigung: `proxy_management` `Content-Type: application/json` `Idempotency-Key` · 16–100 Buchstaben, Ziffern, _ oder -. Für denselben Vorgang speichern und wiederverwenden. ## Parameter | Name | Typ | Erforderlich / Bedingt | Standardwert | Beschreibung | |---|---|---|---|---| | `Idempotency-Key` (header) | string | Erforderlich | — | 16–100 Buchstaben/Ziffern/_/-. Für Vorgang und Status denselben Wert behalten; nicht mit anderem Inhalt wiederverwenden. | | `proxy_id` (body) | integer | Erforderlich | — | Eigene aktive Proxy-Datensatz-ID; 1–2147483647. | | `ip` (body) | string | Erforderlich | — | Öffentliche IP-Adresse. Unterstützte IP-Familien in authorized_ip_families der proxy_access-Antwort prüfen. Nur selbst über die API hinzugefügte IP-Freigaben können entfernt werden. | | `expected_revision` (body) | string | Erforderlich | — | revision aus der zugehörigen Umfangs-/Einstellungsabfrage: 64 kleine Hexadezimalzeichen. | | `terms` (body) | boolean | Erforderlich | — | Zur ausdrücklichen Zustimmung muss der JSON-Wahrheitswert true gesendet werden, nicht die Zeichenfolge "true". | ## Anfrageinhalt Ersetzen Sie YOUR_/FROM_ durch Werte aus Katalog, Angebot oder Umfang. Beispiele lassen die Zustimmung auf false; bestätigen Sie echte Vorgänge nur bewusst. ```json { "proxy_id": "YOUR_PROXY_ID", "ip": "YOUR_PUBLIC_IPV4", "expected_revision": "FROM_SCOPE_REVISION", "terms": false } ``` ## Anfragebeispiel ### curl ```curl printf 'Authorization: Bearer %s\n' "$ARNPROXY_API_KEY" | curl --silent --show-error --header @- \ --header 'Accept: application/json' \ --connect-timeout 10 --max-time 30 \ --header 'Idempotency-Key: YOUR_SAVED_OPERATION_KEY' \ --request POST --header 'Content-Type: application/json' \ --data-binary @request.json \ 'https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove' ``` ### python ```python import os, requests headers = {"Authorization": "Bearer " + os.environ["ARNPROXY_API_KEY"]} headers["Idempotency-Key"] = "YOUR_SAVED_OPERATION_KEY" import json with open("request.json", encoding="utf-8") as f: payload = json.load(f) response = requests.post( "https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove", headers=headers, json=payload, timeout=(10, 30), allow_redirects=False ) print(response.status_code, response.text) # No automatic write retry. ``` ### javascript ```javascript const headers = { Authorization: `Bearer ${process.env.ARNPROXY_API_KEY}` }; headers['Idempotency-Key'] = 'YOUR_SAVED_OPERATION_KEY'; const { readFile } = await import('node:fs/promises'); headers['Content-Type'] = 'application/json'; const body = await readFile('request.json', 'utf8'); const response = await fetch("https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove", { method: 'POST', headers, redirect: 'error', signal: AbortSignal.timeout(30000), body }); console.log(response.status, await response.text()); // A write timeout is ambiguous; query its saved operation. ``` ### php ```php true, CURLOPT_HTTPHEADER => $headers, CURLOPT_FOLLOWLOCATION => false, CURLOPT_SSL_VERIFYPEER => true, CURLOPT_SSL_VERIFYHOST => 2, CURLOPT_CONNECTTIMEOUT => 10, CURLOPT_TIMEOUT => 30, CURLOPT_POST => true, CURLOPT_POSTFIELDS => file_get_contents('request.json'), ]); $result = curl_exec($ch); if ($result === false) { // Do not repeat a write; use the original operation key. throw new RuntimeException('Transport result unknown'); } echo curl_getinfo($ch, CURLINFO_HTTP_CODE).PHP_EOL.$result; curl_close($ch); ``` ### go ```go package main import ( "fmt" "io" "net/http" "os" "time" ) func main() { client := &http.Client{Timeout: 30*time.Second, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }} var body io.Reader file, err := os.Open("request.json"); if err != nil { panic(err) } defer file.Close(); body = file req, err := http.NewRequest("POST", "https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove", body) if err != nil { panic(err) } req.Header.Set("Authorization", "Bearer "+os.Getenv("ARNPROXY_API_KEY")) req.Header.Set("Idempotency-Key", "YOUR_SAVED_OPERATION_KEY") req.Header.Set("Content-Type", "application/json") res, err := client.Do(req); if err != nil { panic(err) } defer res.Body.Close() data, err := io.ReadAll(res.Body); if err != nil { panic(err) } fmt.Println(res.StatusCode, string(data)) } ``` ### csharp ```csharp using System; using System.IO; using System.Net.Http; using System.Net.Http.Headers; using System.Text; using var handler = new HttpClientHandler { AllowAutoRedirect = false }; using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) }; using var request = new HttpRequestMessage(HttpMethod.Post, "https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove"); request.Headers.Authorization = new AuthenticationHeaderValue( "Bearer", Environment.GetEnvironmentVariable("ARNPROXY_API_KEY")); request.Headers.Add("Idempotency-Key", "YOUR_SAVED_OPERATION_KEY"); request.Content = new StringContent( await File.ReadAllTextAsync("request.json"), Encoding.UTF8, "application/json"); using var response = await client.SendAsync(request); Console.WriteLine((int)response.StatusCode); Console.WriteLine(await response.Content.ReadAsStringAsync()); // Never automatically retry an ambiguous write. ``` ### java ```java import java.net.URI; import java.net.http.*; import java.nio.charset.StandardCharsets; import java.nio.file.*; // Inside your application method: var client = HttpClient.newHttpClient(); var request = HttpRequest.newBuilder(URI.create("https://www.arnproxy.com/account/api/v1/proxies/authorized-ips/remove")) .header("Authorization", "Bearer " + System.getenv("ARNPROXY_API_KEY")) .header("Accept", "application/json") .header("Idempotency-Key", System.getenv("ARNPROXY_OPERATION_KEY")) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString( Files.readString(Path.of("request.json"), StandardCharsets.UTF_8))) .build(); var response = client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println(response.statusCode()); ``` ## Antworten · HTTP 200, 202 ```json { "ok": true, "data": { "state": "completed", "action": "ip_remove", "proxy_ids": [ 12345 ], "reason_code": null, "replayed": false, "provider_write_steps_sent": 1, "resume_available": false, "primary_credentials_locked": true, "credentials_returned": false, "balance_changed": false, "proxy_expiry_changed": false, "authorization_scope": "upstream_order", "shared_order_effects_accepted": true, "grant_state": "none" }, "meta": { "request_id": "000000000000000000000001", "phase": "public_v1", "source": "arnproxy_records" } } ``` | Name | Typ | Bedingt | Beschreibung | |---|---|---|---| | `ok` | boolean | — | Erfolgskennzeichen; bei false error.code prüfen. | | `data` | object | — | Vorgangsspezifisches Ergebnis; Beispiele sind synthetisch und dienen der Veranschaulichung. | | `data.state` | string | — | Datensatz-/Vorgangsstatus. accepted bedeutet nicht geliefert, completed keinen Verbindungstest. | | `data.action` | string | — | Vorgangsspezifischer Wert für action. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `data.proxy_ids` | array | — | Proxy-IDs im für dieses Konto sichtbaren Umfang. | | `data.proxy_ids[]` | integer | — | Proxy-IDs im für dieses Konto sichtbaren Umfang. | | `data.reason_code` | string|null | — | Fester Grundcode oder null, niemals ungefilterter Anbieterfehlertext. | | `data.replayed` | boolean | — | Gespeichertes Ergebnis desselben Vorgangs, kein Beweis für neue Abbuchung/Aktion. | | `data.provider_write_steps_sent` | integer | — | Vorgangsspezifischer Wert für provider write steps sent. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `data.resume_available` | boolean | — | Ausdrückliche Fortsetzungsmöglichkeit für einen ungesendeten Schritt; bei false nicht automatisch wiederholen. | | `data.primary_credentials_locked` | boolean | — | Vorgangsspezifischer Wert für primary credentials locked. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `data.credentials_returned` | boolean | — | Vorgangsspezifischer Wert für credentials returned. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `data.balance_changed` | boolean | — | Gemeldete Vorgangswirkung; automatische Verlängerung kann später getrennte Abbuchungen verursachen. | | `data.proxy_expiry_changed` | boolean | — | Gemeldete Vorgangswirkung; automatische Verlängerung kann später getrennte Abbuchungen verursachen. | | `data.authorization_scope` | string | — | Autorisierungsumfang; Bestell-/Paketaktionen können andere Zuordnungen beeinflussen. | | `data.shared_order_effects_accepted` | boolean | — | Vorgangsspezifischer Wert für shared order effects accepted. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `data.grant_state` | string | — | IP-Freigabestatus. Eine Entfernung kann eigenen grant_state=none haben; die ursprüngliche Freigabe wird separat widerrufen. | | `meta` | object | — | Metadaten zu Anfragezuordnung und Datenquelle. | | `meta.request_id` | string | — | Kennung dieser HTTP-Anfrage, kein Vorgangsschlüssel oder Bestell-ID. | | `meta.phase` | string | — | Vorgangsspezifischer Wert für phase. Rückgabetyp beibehalten und Verhaltenshinweise beachten. | | `meta.source` | string | — | Datenquelle; lokale Datensätze und Live-Anbieterabfragen sind unterschiedliche Nachweise. | ## Verhalten & wichtige Hinweise - Eine Aktion kann die gesamte Berechtigungsgruppe, etwa eine Bestellung oder ein Paket, betreffen, nicht nur den gewählten Proxy. Vorher proxy_ids, authorization_scope und may_affect_other_proxies prüfen. Bei geändertem Umfang eine neue revision abrufen. - Entfernen setzt eine eigene API-IP-Freigabe dieses Kontos voraus. Administrator-/Fremdfreigaben sind nicht entfernbar. IP-Freigaben haben getrennte Ablaufprüfungen. - Timeout/5xx beweist keinen Schreibfehler. Ursprünglichen Idempotency-Key für den Status verwenden. Nicht mit neuem Schlüssel wiederholen; GET sendet die Änderung nicht erneut. - Die Freigabeliste unter Mein Konto → API legt fest, welche Adressen den API-Schlüssel verwenden dürfen; sie wird auf der Kontoseite verwaltet. Die IP-Freigabe eines Proxys bestimmt dagegen, welche Adressen sich mit dem Proxy verbinden dürfen. Beide Einstellungen sind unabhängig. Authentifizierung und Validierung können eine Anfrage vor der Ausführung ablehnen. Beachten Sie die Fehlerreferenz und bewahren Sie request_id für den Support auf. Senden Sie niemals Schlüssel oder Passwörter. [Fehler & Limits](https://docs.arnproxy.com/de/api-v1/errors) [Denselben Vorgang verfolgen: Zugriffsvorgang prüfen](https://docs.arnproxy.com/de/api-v1/proxies/access/status)