# Developers
**Source:** https://ro.urlkai.com/de/developers
**Language:** Romanian

---

API documentation

Einstieg

Einstieg 
Authentifizierung 
Bewertungslimit 
Antwortbehandlung 

Benutzerdefinierter Splash 

Benutzerdefinierter Splash 
Listați Splash personalizat

Suprapuneri CTA 

Suprapuneri CTA 
Listați suprapunerile CTA

Fişierele 

Fişierele 
Fișiere de listă 
Încărcați un fișier

Kampagnen 

Kampagnen 
Listați campaniile 
Erstellen Sie eine Kampagne 
Atribuirea unui link către o campanie 
Kampagne aktualisieren 
Ștergeți campania

Kanäle 

Kanäle 
Lista canalelor 
Listați elementele canalului 
Erstellen Sie einen Kanal 
Atribuirea unui articol unui canal 
Kanal aktualisieren 
Ștergeți canalul

Konto 

Konto 
Konto erhalten 
Account aktualisieren

Markendomänen 

Markendomänen 
Listați domeniile de marcă 
Creați un domeniu de marcă 
Domäne aktualisieren 
Ștergeți domeniul

Pixel 

Pixel 
Lista de pixeli 
Creați un pixel 
Pixel aktualisieren 
Ștergeți pixelul

Coduri QR 

Coduri QR 
Listați codurile QR 
Holen Sie sich einen einzigen QR-Code 
Erstellen Sie einen QR-Code 
Actualizați codul QR 
Löschen Sie einen QR-Code

Verknüpfungen 

Verknüpfungen 
Link-uri de listă 
Obțineți un singur link 
Einen Link kürzen 
Link aktualisieren 
Link löschen

Developers

# API-Referenz für Entwickler

An API key is required for requests to be processed by the system. Once a user registers, an API key is automatically generated for this user.

## Einstieg

Damit Anfragen vom System verarbeitet werden können, ist ein API-Schlüssel erforderlich. Sobald sich ein Benutzer registriert, wird automatisch ein API-Schlüssel für diesen Benutzer generiert. Der API-Schlüssel muss mit jeder Anfrage gesendet werden (siehe vollständiges Beispiel unten). Wenn der API-Schlüssel nicht gesendet wird oder abgelaufen ist, wird ein Fehler angezeigt. Bitte achten Sie darauf, Ihren API-Schlüssel geheim zu halten, um Missbrauch zu verhindern.

## Authentifizierung

Um sich beim API-System zu authentifizieren, müssen Sie bei jeder Anfrage Ihren API-Schlüssel als Autorisierungstoken senden. Unten sehen Sie einen Beispielcode.

```
curl --location --request POST 'https://urlkai.com/api/account' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();
curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
));

$response = curl_exec($curl);
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/account',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: ''
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/account"
sarcină utilă = {}
anteturi = {
  "Autorizație": "Purtătorul YOURAPIKEY",
  'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

## Bewertungslimit

Unsere API verfügt über einen Ratenbegrenzer zum Schutz vor Anfragenspitzen, um ihre Stabilität zu maximieren. Unser Ratenbegrenzer ist derzeit auf 30 Anfragen pro 1 Minute begrenzt. Vă rugăm să rețineți că tariful se poate modifica în funcție de planul subscris.

Neben der Antwort werden mehrere Header gesendet, die untersucht werden können, um verschiedene Informationen über die Anfrage zu ermitteln.

```
X-RateLimit-Limit: 30X-RateLimit-Remaining: 29X-RateLimit-Reset: TIMESTAMP
```

## Antwortbehandlung

Alle API-Antworten werden standardmäßig im JSON-Format zurückgegeben. Um diese in verwertbare Daten umzuwandeln, muss je nach Sprache die entsprechende Funktion verwendet werden. In PHP kann die Funktion json\_decode() verwendet werden, um die Daten entweder in ein Objekt (Standard) oder ein Array (den zweiten Parameter auf true zu setzen) zu konvertieren. Es ist sehr wichtig, den Fehlerschlüssel zu überprüfen, da er Auskunft darüber gibt, ob ein Fehler aufgetreten ist oder nicht. Sie können auch den Header-Code überprüfen.

```
{
    "error": 1,
    "message": "An error occurred"
}
```

## Benutzerdefinierter Splash

Open in ChatGPT 

Open in Claude

### Listați Splash personalizat

OBȚINE 
`https://urlkai.com/api/splash?limit=2&page=1`

To get Splash Pages via the API, you can use this endpoint. You can also filter data (See table for more info).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/splash?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/splash?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/splash?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/splash?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/splash?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "splash": [
            {
                "id": 1,
                "name": "Produs 1 Promo",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "name": "Promoția produsului 2",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

## Suprapuneri CTA

Open in ChatGPT 

Open in Claude

### Listați suprapunerile CTA

OBȚINE 
`https://urlkai.com/api/overlay?limit=2&page=1`

Pentru a obține suprapuneri cta prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/overlay?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/overlay?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/overlay?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/overlay?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/overlay?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "CTA": [
            {
                "id": 1,
                "type": "mesaj",
                "name": "Produs 1 Promo",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "type": "contact",
                "name": "Pagina de contact",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

## Fişierele

Open in ChatGPT 

Open in Claude

### Fișiere de listă

OBȚINE 
`https://urlkai.com/api/files?limit=2&page=1`

Obțineți toate fișierele. De asemenea, puteți căuta după nume.

| Parametru | Beschreibung |
| --- | --- |
| nume | (opțional) Căutarea unui fișier după nume |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/files?limit=2&page=1' \
--header 'Authorization: Bearer YOURAPIKEY' \
--header 'Content-Type: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/files?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOURAPIKEY",
        "Content-Type: application/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
```

```
var request = require('request');
var options = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/files?limit=2&page=1',
    'headers': {
        'Authorization': 'Bearer YOURAPIKEY',
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
import requests
url = "https://urlkai.com/api/files?limit=2&page=1"
payload = {}
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("GET", url, headers=headers, json=payload)
print(response.text)
```

```
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/files?limit=2&page=1");
request.Headers.Add("Authorization", "Bearer YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": 0,
    "result": 3,
    "perpage": 15,
    "currentpage": 1,
    "nextpage": null,
    "maxpage": 1,
    "list": [
        {
            "id": 1,
            "name": "My Photo",
            "downloads": 10,
            "shorturl": "https:\/\/urlkai.com\/gkOPW",
            "date": "2022-08-09 17:00:00"
        },
        {
            "id": 2,
            "name": "My Documents",
            "downloads": 15,
            "shorturl": "https:\/\/urlkai.com\/uyqEz",
            "date": "2022-08-10 17:01:00"
        },
        {
            "id": 3,
            "name": "My Files",
            "downloads": 5,
            "shorturl": "https:\/\/urlkai.com\/Rzjuj",
            "date": "2022-08-11 19:01:00"
        }
    ]
}
```

### Încărcați un fișier

POST 
`https://urlkai.com/api/files/upload/:filename?name=My+File`

Încărcați un fișier trimițând datele binare ca corp al postării. Trebuie să trimiteți numele fișierului, inclusiv extensia, în loc de :filename în url (de exemplu, brandkit.zip). Puteți seta opțiunile trimițând următorii parametri.

| Parametru | Beschreibung |
| --- | --- |
| nume | (opțional) Nume fișier |
| obicei | (opțional) Alias personalizat în loc de alias aleatoriu. |
| domeniu | (opțional) Domeniu personalizat |
| parolă | (opțional) Protecție prin parolă |
| Expirare | (opțional) Expirarea pentru exemplul de descărcare 2021-09-28 |
| descărcări maxime | (opțional) Numărul maxim de descărcări |

```
curl --location --request POST 'https://urlkai.com/api/files/upload/:filename?name=My+File' \
--header 'Authorization: Bearer YOURAPIKEY' \
--header 'Content-Type: application/json' \
--data-raw '"BINARY DATA"'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/files/upload/:filename?name=My+File",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOURAPIKEY",
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '"BINARY DATA"',
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
```

```
var request = require('request');
var options = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/files/upload/:filename?name=My+File',
    'headers': {
        'Authorization': 'Bearer YOURAPIKEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify("BINARY DATA"),
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
import requests
url = "https://urlkai.com/api/files/upload/:filename?name=My+File"
payload = "BINARY DATA"
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, json=payload)
print(response.text)
```

```
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/files/upload/:filename?name=My+File");
request.Headers.Add("Authorization", "Bearer YOURAPIKEY");
var content = new StringContent(""BINARY DATA"", System.Text.Encoding.UTF8, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": 0,
    "id": 1,
    "shorturl": "https:\/\/urlkai.com\/UMrpL"
}
```

## Kampagnen

Open in ChatGPT 

Open in Claude

### Listați campaniile

OBȚINE 
`https://urlkai.com/api/campaigns?limit=2&page=1`

Pentru a obține campaniile prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/campaigns?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/campaigns?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/campaigns?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/campaigns?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/campaigns?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "campanii": [
            {
                "id": 1,
                "name": "Exemplu de campanie",
                "public": fals,
                "rotator": fals,
                "list": "https:\/\/domain.com\/u\/admin\/list-1"
            },
            {
                "id": 2,
                "domain": "Campanie Facebook",
                "public": adevărat,
                "rotator": "https:\/\/domain.com\/r\/test",
                "list": "https:\/\/domain.com\/u\/admin\/test-2"
            }
        ]
    }
}
```

### Erstellen Sie eine Kampagne

POST 
`https://urlkai.com/api/campaign/add`

O campanie poate fi adăugată folosind acest punct final.

| Parametru | Beschreibung |
| --- | --- |
| nume | (opțional) Numele campaniei |
| melc | (opțional) Rotator Slug |
| public | (opțional) Acces |

```
curl --location --request POST 'https://urlkai.com/api/campaign/add' \
--header 'Authorization: Bearer YOURAPIKEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "New Campaign",
    "slug": "new-campaign",
    "public": true
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/add",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOURAPIKEY",
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "New Campaign",
	    "slug": "new-campaign",
	    "public": true
	}',
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
```

```
var request = require('request');
var options = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/campaign/add',
    'headers': {
        'Authorization': 'Bearer YOURAPIKEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
    "name": "New Campaign",
    "slug": "new-campaign",
    "public": true
}),
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
import requests
url = "https://urlkai.com/api/campaign/add"
payload = {
    "name": "New Campaign",
    "slug": "new-campaign",
    "public": true
}
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, json=payload)
print(response.text)
```

```
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/campaign/add");
request.Headers.Add("Authorization", "Bearer YOURAPIKEY");
var content = new StringContent("{
    "name": "New Campaign",
    "slug": "new-campaign",
    "public": true
}", System.Text.Encoding.UTF8, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": 0,
    "id": 3,
    "domain": "New Campaign",
    "public": true,
    "rotator": "https:\/\/domain.com\/r\/new-campaign",
    "list": "https:\/\/domain.com\/u\/admin\/new-campaign-3"
}
```

### Atribuirea unui link către o campanie

POST 
`https://urlkai.com/api/campaign/:campaignid/assign/:linkid`

Un link scurt poate fi atribuit unei campanii folosind acest punct final. Punctul final necesită ID-ul campaniei și ID-ul linkului scurt.

```
curl --location --request POST 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:campaignid/assign/:linkid",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/campaign/:campaignid/assign/:linkid"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/campaign/:campaignid/assign/:linkid");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Link adăugat cu succes la campanie."
}
```

### Kampagne aktualisieren

PUNE 
`https://urlkai.com/api/campaign/:id/update`

Pentru a actualiza o campanie, trebuie să trimiteți date valide în JSON printr-o solicitare PUT. Datele trebuie trimise ca corp brut al solicitării dvs., așa cum se arată mai jos. Exemplul de mai jos arată toți parametrii pe care îi puteți trimite, dar nu vi se cere să îi trimiteți pe toți (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| nume | (obligatoriu) Numele campaniei |
| melc | (opțional) Rotator Slug |
| public | (opțional) Acces |

```
curl --location --request PUT 'https://urlkai.com/api/campaign/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "name": "Campanie Twitter",
    "slug": "campanie Twitter",
    "public": adevărat
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Campanie Twitter",
	    "slug": "campanie Twitter",
	    "public": adevărat
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/campaign/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "name": "Campanie Twitter",
    "slug": "campanie Twitter",
    "public": adevărat
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/campaign/:id/update"
sarcina utilă = {
    "name": "Campanie Twitter",
    "slug": "campanie Twitter",
    "public": adevărat
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/campaign/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "name": "Campanie Twitter",
    "slug": "campanie Twitter",
    "public": adevărat
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "id": 3,
    "domain": "Campanie Twitter",
    "public": adevărat,
    "rotator": "https:\/\/domain.com\/r\/twitter-campaign",
    "list": "https:\/\/domain.com\/u\/admin\/twitter-campaign-3"
}
```

### Ștergeți campania

ȘTERGE 
`https://urlkai.com/api/campaign/:id/delete`

Pentru a șterge o campanie, trebuie să trimiteți o solicitare de ȘTERGERE.

```
curl --location --request DELETE 'https://urlkai.com/api/campaign/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/campaign/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/campaign/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/campaign/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Campania a fost ștearsă cu succes."
}
```

## Kanäle

Open in ChatGPT 

Open in Claude

### Lista canalelor

OBȚINE 
`https://urlkai.com/api/channels?limit=2&page=1`

Pentru a obține canalele prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/channels?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/channels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/channels?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/channels?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channels?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "canale": [
            {
                "id": 1,
                "name": "Canalul 1",
                "description": "Descrierea canalului 1",
                "color": "#000000",
                "Starred": adevărat
            },
            {
                "id": 2,
                "name": "Canalul 2",
                "description": "Descrierea canalului 2",
                "color": "#FF0000",
                "Starred": fals
            }
        ]
    }
}
```

### Listați elementele canalului

OBȚINE 
`https://urlkai.com/api/channel/:id?limit=1&page=1`

Pentru a obține elemente dintr-un anumit canal prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/channel/:id?limit=1&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id?limit=1&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/channel/:id?limit=1&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/channel/:id?limit=1&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channel/:id?limit=1&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "articole": [
            {
                "type": "linkuri",
                "id": 1,
                "title": "Exemplul meu de link",
                "preview": "https:\/\/google.com",
                "link": "https:\/\/urlkai.com\/google",
                "data": "2022-05-12"
            },
            {
                "type": "bio",
                "id": 1,
                "title": "Exemplul meu de biografie",
                "preview": "https:\/\/urlkai.com\/mybio",
                "link": "https:\/\/urlkai.com\/mybio",
                "data": "2022-06-01"
            }
        ]
    }
}
```

### Erstellen Sie einen Kanal

POST 
`https://urlkai.com/api/channel/add`

Un canal poate fi adăugat folosind acest punct final.

| Parametru | Beschreibung |
| --- | --- |
| nume | (obligatoriu) Numele canalului |
| descriere | (opțional) Descrierea canalului |
| culoare | (opțional) Culoarea insignei canalului (HEX) |
| Jucat | (opțional) Marcați canalul cu o stea sau nu (adevărat sau fals) |

```
curl --location --request POST 'https://urlkai.com/api/channel/add' \
--header 'Authorization: Bearer YOURAPIKEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "New Channel",
    "description": "my new channel",
    "color": "#000000",
    "starred": true
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/add",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOURAPIKEY",
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "New Channel",
	    "description": "my new channel",
	    "color": "#000000",
	    "starred": true
	}',
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
```

```
var request = require('request');
var options = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/channel/add',
    'headers': {
        'Authorization': 'Bearer YOURAPIKEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
    "name": "New Channel",
    "description": "my new channel",
    "color": "#000000",
    "starred": true
}),
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
import requests
url = "https://urlkai.com/api/channel/add"
payload = {
    "name": "New Channel",
    "description": "my new channel",
    "color": "#000000",
    "starred": true
}
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, json=payload)
print(response.text)
```

```
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/channel/add");
request.Headers.Add("Authorization", "Bearer YOURAPIKEY");
var content = new StringContent("{
    "name": "New Channel",
    "description": "my new channel",
    "color": "#000000",
    "starred": true
}", System.Text.Encoding.UTF8, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": 0,
    "id": 3,
    "name": "New Channel",
    "description": "my new channel",
    "color": "#000000",
    "starred": true
}
```

### Atribuirea unui articol unui canal

POST 
`https://urlkai.com/api/channel/:channelid/assign/:type/:itemid`

Un articol poate fi atribuit oricărui canal prin trimiterea unei solicitări cu ID-ul canalului, tipul articolului (link-uri, biografie sau qr) și ID-ul articolului.

| Parametru | Beschreibung |
| --- | --- |
| :channelid | (obligatoriu) ID-ul canalului |
| :tip | (obligatoriu) link-uri sau bio sau qr |
| :itemid | (obligatoriu) ID articol |

```
curl --location --request POST 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Element adăugat cu succes la canal."
}
```

### Kanal aktualisieren

PUNE 
`https://urlkai.com/api/channel/:id/update`

Pentru a actualiza un canal, trebuie să trimiteți date valide în JSON printr-o solicitare PUT. Datele trebuie trimise ca corp brut al solicitării dvs., așa cum se arată mai jos. Exemplul de mai jos arată toți parametrii pe care îi puteți trimite, dar nu vi se cere să îi trimiteți pe toți (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| nume | (opțional) Numele canalului |
| descriere | (opțional) Descrierea canalului |
| culoare | (opțional) Culoarea insignei canalului (HEX) |
| Jucat | (opțional) Marcați canalul cu o stea sau nu (adevărat sau fals) |

```
curl --location --request PUT 'https://urlkai.com/api/channel/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "name": "Acme Corp",
    "description": "canal pentru articole pentru Acme Corp",
    "color": "#FFFFFF",
    "Starred": fals
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Acme Corp",
	    "description": "canal pentru articole pentru Acme Corp",
	    "color": "#FFFFFF",
	    "Starred": fals
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/channel/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "name": "Acme Corp",
    "description": "canal pentru articole pentru Acme Corp",
    "color": "#FFFFFF",
    "Starred": fals
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/channel/:id/update"
sarcina utilă = {
    "name": "Acme Corp",
    "description": "canal pentru articole pentru Acme Corp",
    "color": "#FFFFFF",
    "Starred": fals
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/channel/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "name": "Acme Corp",
    "description": "canal pentru articole pentru Acme Corp",
    "color": "#FFFFFF",
    "Starred": fals
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Canalul a fost actualizat cu succes."
}
```

### Ștergeți canalul

ȘTERGE 
`https://urlkai.com/api/channel/:id/delete`

Pentru a șterge un canal, trebuie să trimiți o solicitare de ȘTERGERE. Toate elementele vor fi de asemenea anulate.

```
curl --location --request DELETE 'https://urlkai.com/api/channel/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/channel/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/channel/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/channel/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Canalul a fost șters cu succes."
}
```

## Konto

Open in ChatGPT 

Open in Claude

### Konto erhalten

OBȚINE 
`https://urlkai.com/api/account`

Um Informationen über das Konto zu erhalten, können Sie eine Anfrage an diesen Endpunkt senden, der Daten über das Konto zurückgibt.

```
curl --location --request GET 'https://urlkai.com/api/account' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/account',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/account"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "date": {
        "id": 1,
        "e-mail": " [e-mail protejat] ",
        "username": "sampleuser",
        "avatar": "https:\/\/domain.com\/content\/avatar.png",
        "status": "pro",
        "expiră": "2022-11-15 15:00:00",
        "Înregistrat": "2020-11-10 18:01:43"
    }
}
```

### Account aktualisieren

PUNE 
`https://urlkai.com/api/account/update`

Um Informationen zu dem Konto zu aktualisieren, können Sie eine Anfrage an diesen Endpunkt senden und er aktualisiert die Daten zu dem Konto.

```
curl --location --request PUT 'https://urlkai.com/api/account/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "e-mail": " [e-mail protejat] ",
    "password": "NewPassword1"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/account/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "e-mail": " [e-mail protejat] ",
	    "password": "NewPassword1"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/account/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "e-mail": " [e-mail protejat] ",
    "password": "NewPassword1"
}),
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/account/update"
sarcina utilă = {
    "e-mail": " [e-mail protejat] ",
    "password": "NewPassword1"
}
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("PUT", url, headers=headers, json=payload)
print(response.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/account/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "e-mail": " [e-mail protejat] ",
    "password": "NewPassword1"
}", System.Text.Encoding.UTF8, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Contul a fost actualizat cu succes."
}
```

## Markendomänen

Open in ChatGPT 

Open in Claude

### Listați domeniile de marcă

OBȚINE 
`https://urlkai.com/api/domains?limit=2&page=1`

Pentru a obține domeniile de marcă prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/domains?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/domains?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/domains?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/domains?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/domains?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "domenii": [
            {
                "id": 1,
                "domeniu": "https:\/\/domain1.com",
                "redirectroot": "https:\/\/rootdomain.com",
                "redirect404": "https:\/\/rootdomain.com\/404"
            },
            {
                "id": 2,
                "domeniu": "https:\/\/domain2.com",
                "redirectroot": "https:\/\/rootdomain2.com",
                "redirect404": "https:\/\/rootdomain2.com\/404"
            }
        ]
    }
}
```

### Creați un domeniu de marcă

POST 
`https://urlkai.com/api/domain/add`

Un domeniu poate fi adăugat folosind acest punct final. Vă rugăm să vă asigurați că domeniul este direcționat corect către serverul nostru.

| Parametru | Beschreibung |
| --- | --- |
| domeniu | (obligatoriu) Domeniu de marcă, inclusiv http sau https |
| redirecționare rădăcină | (opțional) Redirecționare root atunci când cineva îți vizitează domeniul |
| redirecționare404 | (opțional) Redirecționare 404 personalizată |

```
curl --location --request POST 'https://urlkai.com/api/domain/add' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "domeniu": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/domain/add",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "domeniu": "https:\/\/domain1.com",
	    "redirectroot": "https:\/\/rootdomain.com",
	    "redirect404": "https:\/\/rootdomain.com\/404"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/domain/add',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "domeniu": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/domain/add"
sarcina utilă = {
    "domain": "https://domain1.com",
    "redirectroot": "https://rootdomain.com",
    "redirect404": "https://rootdomain.com/404"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/domain/add");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "domeniu": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "ID": 1
}
```

### Domäne aktualisieren

PUNE 
`https://urlkai.com/api/domain/:id/update`

Pentru a actualiza un domeniu de marcă, trebuie să trimiteți date valide în JSON printr-o solicitare PUT. Datele trebuie trimise ca corp brut al solicitării dvs., așa cum se arată mai jos. Exemplul de mai jos arată toți parametrii pe care îi puteți trimite, dar nu vi se cere să îi trimiteți pe toți (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| redirecționare rădăcină | (opțional) Redirecționare root atunci când cineva îți vizitează domeniul |
| redirecționare404 | (opțional) Redirecționare 404 personalizată |

```
curl --location --request PUT 'https://urlkai.com/api/domain/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "redirectroot": "https:\/\/rootdomain-new.com",
	    "redirect404": "https:\/\/rootdomain-new.com\/404"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/domain/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/domain/:id/update"
sarcina utilă = {
    "redirectroot": "https://rootdomain-new.com",
    "redirect404": "https://rootdomain-new.com/404"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/domain/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Domeniul a fost actualizat cu succes."
}
```

### Ștergeți domeniul

ȘTERGE 
`https://urlkai.com/api/domain/:id/delete`

Pentru a șterge un domeniu, trebuie să trimiteți o solicitare de ȘTERGERE.

```
curl --location --request DELETE 'https://urlkai.com/api/domain/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/domain/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/domain/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/domain/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Domeniul a fost șters cu succes."
}
```

## Pixel

Open in ChatGPT 

Open in Claude

### Lista de pixeli

OBȚINE 
`https://urlkai.com/api/pixels?limit=2&page=1`

Pentru a obține codurile pixelilor prin API, puteți utiliza acest punct final. De asemenea, puteți filtra datele (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/pixels?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/pixels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/pixels?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/pixels?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/pixels?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "pixeli": [
            {
                "id": 1,
                "type": "gtmpixel",
                "name": "GTM Pixel",
                "tag": "GA-123456789",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "type": "twitterpixel",
                "name": "Twitter Pixel",
                "tag": "1234567",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

### Creați un pixel

POST 
`https://urlkai.com/api/pixel/add`

Un pixel poate fi creat folosind acest punct final. Trebuie să trimiteți tipul de pixel și eticheta.

| Parametru | Beschreibung |
| --- | --- |
| tip | (obligatoriu) gtmpixel | gapixel | fbpixel | adwordspixel | LinkedInPixel | TwitterPixel | AdrollPixel | Quorapixel | Pinterest | Bing | Snapchat | reddit | TikTok |
| nume | (obligatoriu) Nume personalizat pentru pixel |
| etichetă | (obligatoriu) Eticheta pentru pixel |

```
curl --location --request POST 'https://urlkai.com/api/pixel/add' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "type": "gtmpixel",
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/pixel/add",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "type": "gtmpixel",
	    "name": "GTM-ul meu",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/pixel/add',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "type": "gtmpixel",
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/pixel/add"
sarcina utilă = {
    "type": "gtmpixel",
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/pixel/add");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "type": "gtmpixel",
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "ID": 1
}
```

### Pixel aktualisieren

PUNE 
`https://urlkai.com/api/pixel/:id/update`

Pentru a actualiza un pixel, trebuie să trimiteți date valide în JSON printr-o solicitare PUT. Datele trebuie trimise ca corp brut al solicitării dvs., așa cum se arată mai jos. Exemplul de mai jos arată toți parametrii pe care îi puteți trimite, dar nu vi se cere să îi trimiteți pe toți (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| nume | (opțional) Nume personalizat pentru pixel |
| etichetă | (obligatoriu) Eticheta pentru pixel |

```
curl --location --request PUT 'https://urlkai.com/api/pixel/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "GTM-ul meu",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/pixel/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/pixel/:id/update"
sarcina utilă = {
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = nou HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/pixel/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "name": "GTM-ul meu",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Pixel a fost actualizat cu succes."
}
```

### Ștergeți pixelul

ȘTERGE 
`https://urlkai.com/api/pixel/:id/delete`

Pentru a șterge un pixel, trebuie să trimiteți o solicitare de ȘTERGERE.

```
curl --location --request DELETE 'https://urlkai.com/api/pixel/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/pixel/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/pixel/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/pixel/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Pixelul a fost șters cu succes."
}
```

## Coduri QR

Open in ChatGPT 

Open in Claude

### Listați codurile QR

OBȚINE 
`https://urlkai.com/api/qr?limit=2&page=1`

Um Ihre QR-Codes über die API abzurufen, können Sie diesen Endpunkt verwenden. Sie können Daten auch filtern (weitere Informationen finden Sie in der Tabelle).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |

```
curl --location --request GET 'https://urlkai.com/api/qr?limit=2&page=1' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/qr?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/qr?limit=2&page=1',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/qr?limit=2&page=1"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr?limit=2&page=1");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "qrs": [
            {
                "id": 2,
                "link": "https:\/\/urlkai.com\/qr\/a2d5e",
                "scanări": 0,
                "name": "Google",
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "link": "https:\/\/urlkai.com\/qr\/b9edfe",
                "scanări": 5,
                "name": "Google Canada",
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

### Holen Sie sich einen einzigen QR-Code

OBȚINE 
`https://urlkai.com/api/qr/:id`

Um Details für einen einzelnen QR-Code über die API abzurufen, können Sie diesen Endpunkt verwenden.

```
curl --location --request GET 'https://urlkai.com/api/qr/:id' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/qr/:id',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/qr/:id"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr/:id");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "detalii": {
        "id": 1,
        "link": "https:\/\/urlkai.com\/qr\/b9edfe",
        "scanări": 5,
        "name": "Google Canada",
        "data": "2020-11-10 18:00:25"
    },
    "date": {
        "clicuri": 1,
        "uniqueClicks": 1,
        "topCountries": {
            "Necunoscut": "1"
        },
        "topReferrers": {
            "Direct, e-mail și altele": "1"
        },
        "topBrowsers": {
            "Chrome": "1"
        },
        "topOs": {
            "Windows 10": "1"
        },
        "socialCount": {
            "facebook": 0,
            "Twitter": 0,
            "Instagram": 0
        }
    }
}
```

### Erstellen Sie einen QR-Code

POST 
`https://urlkai.com/api/qr/add`

Pentru a crea un cod QR, trebuie să trimiteți date valide în JSON printr-o solicitare POST. Datele trebuie trimise ca corp brut al solicitării dvs., așa cum se arată mai jos. Exemplul de mai jos arată toți parametrii pe care îi puteți trimite, dar nu vi se cere să îi trimiteți pe toți (consultați tabelul pentru mai multe informații).

| Parametru | Beschreibung |
| --- | --- |
| tip | text (obligatoriu) | vcard | legătură | E-mail | telefon | SMS | Wi-Fi |
| date | (obligatoriu) Date care trebuie încorporate în codul QR. Datele pot fi șir sau matrice în funcție de tip |
| fond | (opțional) Culoare RGB, de exemplu rgb (255,255,255) |
| Prim plan | (opțional) Culoare RGB, de exemplu rgb(0,0,0) |
| siglă | (opțional) Calea către logo, fie png, fie jpg |
| nume | (opțional) Numele codului QR |

```
curl --location --request POST 'https://urlkai.com/api/qr/add' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API cod QR"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/qr/add",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "type": "link",
	    "data": "https:\/\/google.com",
	    "background": "rgb(255,255,255)",
	    "prim-plan": "rgb(0,0,0)",
	    "logo": "https:\/\/site.com\/logo.png",
	    "name": "API cod QR"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/qr/add',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API cod QR"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/qr/add"
sarcina utilă = {
    "type": "link",
    "data": "https://google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https://site.com/logo.png",
    "name": "API cod QR"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/qr/add");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API cod QR"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "id": 3,
    "link": "https:\/\/urlkai.com\/qr\/a58f79"
}
```

### Actualizați codul QR

PUNE 
`https://urlkai.com/api/qr/:id/update`

Um einen QR-Code zu aktualisieren, müssen Sie gültige Daten in JSON über eine PUT-Anforderung senden. Die Daten müssen wie unten gezeigt als Rohtext Ihrer Anfrage gesendet werden. Das folgende Beispiel zeigt alle Parameter, die Sie senden können, aber Sie müssen nicht alle senden (siehe Tabelle für weitere Informationen).

| Parametru | Beschreibung |
| --- | --- |
| date | (obligatoriu) Date care trebuie încorporate în codul QR. Datele pot fi șir sau matrice în funcție de tip |
| fond | (opțional) Culoare RGB, de exemplu rgb (255,255,255) |
| Prim plan | (opțional) Culoare RGB, de exemplu rgb(0,0,0) |
| siglă | (opțional) Calea către logo, fie png, fie jpg |

```
curl --location --request PUT 'https://urlkai.com/api/qr/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "type": "link",
	    "data": "https:\/\/google.com",
	    "background": "rgb(255,255,255)",
	    "prim-plan": "rgb(0,0,0)",
	    "logo": "https:\/\/site.com\/logo.png"
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/qr/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/qr/:id/update"
sarcina utilă = {
    "type": "link",
    "data": "https://google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https://site.com/logo.png"
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = nou HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/qr/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "type": "link",
    "data": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "prim-plan": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "QR a fost actualizat cu succes."
}
```

### Löschen Sie einen QR-Code

ȘTERGE 
`https://urlkai.com/api/qr/:id/delete`

Um einen QR-Code zu löschen, müssen Sie eine DELETE-Anfrage senden.

```
curl --location --request DELETE 'https://urlkai.com/api/qr/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/qr/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/qr/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/qr/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Codul QR a fost șters cu succes."
}
```

## Verknüpfungen

Open in ChatGPT 

Open in Claude

### Link-uri de listă

OBȚINE 
`https://urlkai.com/api/urls?limit=2&page=1o=date`

Um Ihre Links über die API zu erhalten, können Sie diesen Endpunkt verwenden. Sie können Daten auch filtern (weitere Informationen finden Sie in der Tabelle).

| Parametru | Beschreibung |
| --- | --- |
| limită | (opțional) Rezultat de date pe pagină |
| pagină | (opțional) Solicitare pagină curentă |
| ordine | (opțional) Sortarea datelor între dată sau clic |
| scurt | (opțional) Căutați folosind adresa URL scurtă. Rețineți că atunci când utilizați parametrul scurt, toți ceilalți parametri sunt ignorați și, dacă există o potrivire, va fi returnat un răspuns Single Link. |
| q | (opțional) Căutați linkuri folosind un cuvânt cheie |

```
curl --location --request GET 'https://urlkai.com/api/urls?limit=2&page=1o=date' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/urls?limit=2&page=1o=date",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/urls?limit=2&page=1o=date',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/urls?limit=2&page=1o=date"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/urls?limit=2&page=1o=date");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "error": "0",
    "date": {
        "rezultat": 2,
        "perpage": 2,
        "pagina curentă": 1,
        "pagina următoare": 1,
        "maxpage": 1,
        "URL-uri": [
            {
                "id": 2,
                "alias": "google",
                "shorturl": "https:\/\/urlkai.com\/google",
                "longURL": "https:\/\/google.com",
                "clicuri": 0,
                "title": "Google",
                "description": "",
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "alias": "googlecanada",
                "shorturl": "https:\/\/urlkai.com\/googlecanada",
                "longurl": "https:\/\/google.ca",
                "clicuri": 0,
                "title": "Google Canada",
                "description": "",
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

### Obțineți un singur link

OBȚINE 
`https://urlkai.com/api/url/:id`

Um Details für einen einzelnen Link über die API abzurufen, können Sie diesen Endpunkt verwenden.

```
curl --location --request GET 'https://urlkai.com/api/url/:id' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/url/:id",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "GET",
    'url': 'https://urlkai.com/api/url/:id',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/url/:id"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("GET", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = nou HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/url/:id");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "id": 1,
    "detalii": {
        "id": 1,
        "shorturl": "https:\/\/urlkai.com\/googlecanada",
        "longURL": "https:\/\/google.com",
        "title": "Google",
        "description": "",
        "locație": {
            "Canada": "https:\/\/google.ca",
            "Statele Unite": "https:\/\/google.us"
        },
        "dispozitiv": {
            "iPhone": "https:\/\/google.com",
            "android": "https:\/\/google.com"
        },
        "expirare": nul;
        "data": "2020-11-10 18:01:43"
    },
    "date": {
        "clicuri": 0,
        "uniqueClicks": 0,
        "topCountries": 0,
        "topReferrers": 0,
        "topBrowsers": 0,
        "topOs": 0,
        "socialCount": {
            "facebook": 0,
            "Twitter": 0,
            "google": 0
        }
    }
}
```

### Einen Link kürzen

POST 
`https://urlkai.com/api/url/add`

Um einen Link zu kürzen, müssen Sie gültige Daten in JSON über eine POST-Anforderung senden. Die Daten müssen wie unten gezeigt als Rohtext Ihrer Anfrage gesendet werden. Das folgende Beispiel zeigt alle Parameter, die Sie senden können, aber Sie müssen nicht alle senden (siehe Tabelle für weitere Informationen).

| Parametru | Beschreibung |
| --- | --- |
| Adresa URL | (obligatoriu) URL lung de scurtat. |
| obicei | (opțional) Alias personalizat în loc de alias aleatoriu. |
| tip | (opțional) Tipul de redirecționare [direct, frame, splash], numai *Id* pentru pagina de pornire personalizată sau *overlay-id* Pentru paginile CTA |
| parolă | (opțional) Protecție prin parolă |
| domeniu | (opțional) Domeniu personalizat |
| Expirare | (opțional) Expirarea pentru exemplul de link 2021-09-28 23:11:16 |
| Țintă geografică | (opțional) Date de direcționare geografică |
| dispozitiv țintă | (opțional) Date de direcționare pe dispozitiv |
| LanguageTarget | (opțional) Date de direcționare în funcție de limbă |
| metatitlu | (opțional) Meta titlu |
| Metadescriere | (opțional) Meta descriere |
| metaimagine | (opțional) Link către o imagine jpg sau png |
| descriere | (opțional) Notă sau descriere |
| Pixeli | (opțional) Matrice de ID-uri de pixeli |
| canal | (opțional) ID-ul canalului |
| campanie | (opțional) Codul campaniei |
| legătura profundă | (optional) Object containing app store links. When using this, it is important to set device targeting as well. (New) You can now set the parameter "auto" to true to automatically generate the deep links from provided long link. |
| stare | (opțional) *public* sau *private (implicit)* |

```
curl --location --request POST 'https://urlkai.com/api/url/add' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "url": "https:\/\/google.com",
    "status": "privat",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "metatitle": "Nu Google",
    "metadescription": "Nu este descrierea Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Pentru facebook",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanie": 1,
    "deeplink": {
        "auto": adevărat,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "language": "en",
            "link": "https:\/\/google.com"
        },
        {
            "language": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/url/add",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "status": "privat",
	    "custom": "google",
	    "password": "mypass",
	    "expiry": "2020-11-11 12:00:00",
	    "type": "stropire",
	    "metatitle": "Nu Google",
	    "metadescription": "Nu este descrierea Google",
	    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
	    "description": "Pentru facebook",
	    "pixeli": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canal": 1,
	    "campanie": 1,
	    "deeplink": {
	        "auto": adevărat,
	        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
	        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
	    },
	    "geotarget": [
	        {
	            "location": "Canada",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Statele Unite",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "devicetarget": [
	        {
	            "device": "iPhone",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "device": "Android",
	            "link": "https:\/\/google.com"
	        }
	    ],
	    "languagetarget": [
	        {
	            "language": "en",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "language": "fr",
	            "link": "https:\/\/google.ca"
	        }
	    ],
	    "parametri": [
	        {
	            "name": "aff",
	            "valoare": "3"
	        },
	        {
	            "dispozitiv": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "POST",
    'url': 'https://urlkai.com/api/url/add',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "url": "https:\/\/google.com",
    "status": "privat",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "metatitle": "Nu Google",
    "metadescription": "Nu este descrierea Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Pentru facebook",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanie": 1,
    "deeplink": {
        "auto": adevărat,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "language": "en",
            "link": "https:\/\/google.com"
        },
        {
            "language": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/url/add"
sarcina utilă = {
    "url": "https://google.com",
    "status": "privat",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "metatitle": "Nu Google",
    "metadescription": "Nu este descrierea Google",
    "metaimage": "https://www.mozilla.org/media/protocol/img/logos/firefox/browser/og.4ad05d4125a5.png",
    "description": "Pentru facebook",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanie": 1,
    "deeplink": {
        "auto": adevărat,
        "apple": "https://apps.apple.com/us/app/google/id284815942",
        "google": "https://play.google.com/store/apps/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https://google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https://google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "device": "Android",
            "link": "https://google.com"
        }
    ],
    "languagetarget": [
        {
            "language": "en",
            "link": "https://google.com"
        },
        {
            "language": "fr",
            "link": "https://google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("POST", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/url/add");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "status": "privat",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "metatitle": "Nu Google",
    "metadescription": "Nu este descrierea Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Pentru facebook",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanie": 1,
    "deeplink": {
        "auto": adevărat,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "language": "en",
            "link": "https:\/\/google.com"
        },
        {
            "language": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "id": 3,
    "shorturl": "https:\/\/urlkai.com\/google"
}
```

### Link aktualisieren

PUNE 
`https://urlkai.com/api/url/:id/update`

Um einen Link zu aktualisieren, müssen Sie gültige Daten in JSON über eine PUT-Anforderung senden. Die Daten müssen wie unten gezeigt als Rohtext Ihrer Anfrage gesendet werden. Das folgende Beispiel zeigt alle Parameter, die Sie senden können, aber Sie müssen nicht alle senden (siehe Tabelle für weitere Informationen).

| Parametru | Beschreibung |
| --- | --- |
| Adresa URL | (obligatoriu) URL lung de scurtat. |
| obicei | (opțional) Alias personalizat în loc de alias aleatoriu. |
| tip | (opțional) Tip de redirecționare [direct, frame, splash] |
| parolă | (opțional) Protecție prin parolă |
| domeniu | (opțional) Domeniu personalizat |
| Expirare | (opțional) Expirarea pentru exemplul de link 2021-09-28 23:11:16 |
| Țintă geografică | (opțional) Date de direcționare geografică |
| dispozitiv țintă | (opțional) Date de direcționare pe dispozitiv |
| LanguageTarget | (opțional) Date de direcționare în funcție de limbă |
| metatitlu | (opțional) Meta titlu |
| Metadescriere | (opțional) Meta descriere |
| metaimagine | (opțional) Link către o imagine jpg sau png |
| Pixeli | (opțional) Matrice de ID-uri de pixeli |
| canal | (opțional) ID-ul canalului |
| campanie | (opțional) Codul campaniei |
| legătura profundă | (opțional) Obiect care conține linkuri din magazinul de aplicații. Când utilizați acest lucru, este important să setați și direcționarea dispozitivului. |

```
curl --location --request PUT 'https://urlkai.com/api/url/:id/update' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
--data-raw '{
    "url": "https:\/\/google.com",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/url/:id/update",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "custom": "google",
	    "password": "mypass",
	    "expiry": "2020-11-11 12:00:00",
	    "type": "stropire",
	    "pixeli": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canal": 1,
	    "deeplink": {
	        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
	        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
	    },
	    "geotarget": [
	        {
	            "location": "Canada",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Statele Unite",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "devicetarget": [
	        {
	            "device": "iPhone",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "device": "Android",
	            "link": "https:\/\/google.com"
	        }
	    ],
	    "parametri": [
	        {
	            "name": "aff",
	            "valoare": "3"
	        },
	        {
	            "dispozitiv": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "metodă": "PUT",
    'url': 'https://urlkai.com/api/url/:id/update',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    corp: JSON.stringify({
    "url": "https:\/\/google.com",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/url/:id/update"
sarcina utilă = {
    "url": "https://google.com",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https://apps.apple.com/us/app/google/id284815942",
        "google": "https://play.google.com/store/apps/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https://google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https://google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "device": "Android",
            "link": "https://google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("PUT", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/url/:id/update");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "custom": "google",
    "password": "mypass",
    "expiry": "2020-11-11 12:00:00",
    "type": "stropire",
    "pixeli": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "geotarget": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Statele Unite",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valoare": "3"
        },
        {
            "dispozitiv": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "aplicație/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "id": 3,
    "short": "https:\/\/urlkai.com\/google"
}
```

### Link löschen

ȘTERGE 
`https://urlkai.com/api/url/:id/delete`

Um einen Link zu löschen, müssen Sie eine DELETE-Anfrage senden.

```
curl --location --request DELETE 'https://urlkai.com/api/url/:id/delete' \
--header 'Autorizare: Purtător YOURAPIKEY' \
--header 'Tip de conținut: aplicație/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, matrice(
    CURLOPT_URL => "https://urlkai.com/api/url/:id/delete",
    CURLOPT_RETURNTRANSFER => adevărat,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => adevărat,
    CURLOPT_CUSTOMREQUEST => "ȘTERGE",
    CURLOPT_HTTPHEADER => [
        "Autorizație: Purtător YOURAPIKEY",
        "Tip de conținut: aplicație/json",
    ],
    
));

$response = curl_exec($curl);

curl_close($curl);
ecou $response;
```

```
var request = require('request');
var options = {
    "method": "DELETE",
    'url': 'https://urlkai.com/api/url/:id/delete',
    'anteturi': {
        "Autorizație": "Purtătorul YOURAPIKEY",
        'Content-Type': 'application/json'
    },
    
};
request(options, function (error, response) {
    dacă (eroare) aruncă o nouă eroare (eroare);
    console.log(răspuns.corp);
});
```

```
Solicitări de import
url = "https://urlkai.com/api/url/:id/delete"
sarcină utilă = {}
anteturi = {
    "Autorizație": "Purtătorul YOURAPIKEY",
    'Content-Type': 'application/json'
}
răspuns = requests.request("DELETE", url, headers=headers, json=payload)
print(răspuns.text)
```

```
var client = nou HttpClient();
var request = nou HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/url/:id/delete");
cerere. Headers.Add("Autorizare", "Purtător YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
cerere. Conținut = conținut;
var răspuns = așteaptă clientul. SendAsync(cerere);
răspuns. EnsureSuccessStatusCode();
Console.WriteLine(așteaptă răspunsul. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "eroare": 0,
    "message": "Linkul a fost șters cu succes"
}
```