# Developers
**Source:** https://it.urlkai.com/de/developers
**Language:** Italian

---

API documentation

Einstieg

Einstieg 
Authentifizierung 
Bewertungslimit 
Antwortbehandlung 

Benutzerdefinierter Splash 

Benutzerdefinierter Splash 
Elenca Splash personalizzato

Sovrapposizioni CTA 

Sovrapposizioni CTA 
Elenca le sovrapposizioni CTA

file 

file 
Elenca file 
Caricare un file

Kampagnen 

Kampagnen 
Elenca le campagne 
Erstellen Sie eine Kampagne 
Assegnazione di un link a una campagna 
Kampagne aktualisieren 
Elimina campagna

Kanäle 

Kanäle 
Elenca canali 
Elencare gli elementi del canale 
Erstellen Sie einen Kanal 
Assegnazione di un elemento a un canale 
Kanal aktualisieren 
Elimina canale

Konto 

Konto 
Konto erhalten 
Account aktualisieren

Markendomänen 

Markendomänen 
Elenca i domini con marchio 
Crea un dominio con marchio 
Domäne aktualisieren 
Elimina dominio

Pixel 

Pixel 
Elenco pixel 
Crea un pixel 
Pixel aktualisieren 
Elimina pixel

Codici QR 

Codici QR 
Elenca i codici QR 
Holen Sie sich einen einzigen QR-Code 
Erstellen Sie einen QR-Code 
Aggiorna il codice QR 
Löschen Sie einen QR-Code

Verknüpfungen 

Verknüpfungen 
Elenca collegamenti 
Ottieni un singolo 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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
));

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'URL': 'https://urlkai.com/api/account',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: ''
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/account"
payload = {}
intestazioni = {
  «Autorizzazione»: «Bearer YOURAPIKEY»,
  'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. 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. Si prega di notare che la tariffa potrebbe cambiare in base al piasottoscritto.

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

### Elenca Splash personalizzato

OTTIENI 
`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).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/splash?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/splash?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'url': 'https://urlkai.com/api/splash?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/splash?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/splash?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "spruzzo": [
            {
                "id": 1,
                "name": "Prodotto 1 Promo",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "name": "Prodotto 2 Promo",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

## Sovrapposizioni CTA

Open in ChatGPT 

Open in Claude

### Elenca le sovrapposizioni CTA

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

Per ottenere sovrapposizioni cta tramite l'API, è possibile utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/overlay?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/overlay?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/overlay?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/overlay?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/overlay?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "CTA": [
            {
                "id": 1,
                "type": "messaggio",
                "name": "Prodotto 1 Promo",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "type": "contatto",
                "name": "Pagina dei contatti",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

## file

Open in ChatGPT 

Open in Claude

### Elenca file

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

Recupera tutti i tuoi file. Puoi anche cercare per nome.

| Parametro | Beschreibung |
| --- | --- |
| nome | (Facoltativo) Cercare un file in base al nome |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
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\/jqJyh",
            "date": "2022-08-09 17:00:00"
        },
        {
            "id": 2,
            "name": "My Documents",
            "downloads": 15,
            "shorturl": "https:\/\/urlkai.com\/EhPQg",
            "date": "2022-08-10 17:01:00"
        },
        {
            "id": 3,
            "name": "My Files",
            "downloads": 5,
            "shorturl": "https:\/\/urlkai.com\/ZxVCT",
            "date": "2022-08-11 19:01:00"
        }
    ]
}
```

### Caricare un file

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

Caricare un file inviando i dati binari come corpo del post. È necessario inviare il nome del file includendo l'estensione invece di :filename nell'url (ad es. brandkit.zip). È possibile impostare le opzioni inviando i seguenti parametri.

| Parametro | Beschreibung |
| --- | --- |
| nome | (Facoltativo) Nome file |
| costume | (Facoltativo) Alias personalizzato invece di alias casuali. |
| dominio | (Facoltativo) Dominio personalizzato |
| parola d’ordine | (Facoltativo) Protezione con password |
| scadenza | (Facoltativo) Scadenza per l'esempio di download 2021-09-28 |
| maxdownloads | (Facoltativo) Numero massimo di download |

```
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\/cXyZG"
}
```

## Kampagnen

Open in ChatGPT 

Open in Claude

### Elenca le campagne

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

Per ottenere le tue campagne tramite l'API, puoi utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/campaigns?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaigns?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'url': 'https://urlkai.com/api/campaigns?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/campaigns?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/campaigns?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "campagne": [
            {
                "id": 1,
                "name": "Campagna campione",
                "pubblico": falso,
                "rotatore": falso,
                "list": "https:\/\/domain.com\/u\/admin\/list-1"
            },
            {
                "id": 2,
                "domain": "Campagna Facebook",
                "pubblico": vero,
                "rotator": "https:\/\/domain.com\/r\/test",
                "list": "https:\/\/domain.com\/u\/admin\/test-2"
            }
        ]
    }
}
```

### Erstellen Sie eine Kampagne

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

È possibile aggiungere una campagna utilizzando questo endpoint.

| Parametro | Beschreibung |
| --- | --- |
| nome | (Facoltativo) Nome della campagna |
| Lumaca | (Facoltativo) Lumaca rotatore |
| pubblico | (Facoltativo) Accesso |

```
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

```
{
    "errore": 0,
    "id": 3,
    "dominio": "Nuova Campagna",
    "Pubblico": Vero,
    "rotator": "https:\/\/domain.com\/r\/new-campaign",
    "lista": "https:\/\/domain.com\/u\/admin\/new-campaign-3"
}
```

### Assegnazione di un link a una campagna

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

Un collegamento breve può essere assegnato a una campagna utilizzando questo endpoint. L'endpoint richiede l'ID campagna e l'ID collegamento breve.

```
curl --location --request POST 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:campaignid/assign/:linkid",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'URL': 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/campaign/:campaignid/assign/:linkid"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/campaign/:campaignid/assign/:linkid");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Link aggiunto alla campagna."
}
```

### Kampagne aktualisieren

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

Per aggiornare una campagna, è necessario inviare dati validi in JSON tramite una richiesta PUT. I dati devoessere inviati come corpo grezzo della tua richiesta come mostrato di seguito. L'esempio seguente mostra tutti i parametri che puoi inviare ma non sei obbligato a inviarli tutti (vedi tabella per maggiori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| nome | (obbligatorio) Nome della campagna |
| Lumaca | (Facoltativo) Lumaca rotatore |
| pubblico | (Facoltativo) Accesso |

```
curl --location --request PUT 'https://urlkai.com/api/campaign/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "name": "Campagna Twitter",
    "slug": "campagna su Twitter",
    "pubblico": vero
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Campagna Twitter",
	    "slug": "campagna su Twitter",
	    "pubblico": vero
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'url': 'https://urlkai.com/api/campaign/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "name": "Campagna Twitter",
    "slug": "campagna su Twitter",
    "pubblico": vero
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/campaign/:id/update"
carico utile = {
    "name": "Campagna Twitter",
    "slug": "campagna su Twitter",
    "pubblico": vero
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/campaign/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "name": "Campagna Twitter",
    "slug": "campagna su Twitter",
    "pubblico": vero
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "id": 3,
    "domain": "Campagna Twitter",
    "pubblico": vero,
    "rotator": "https:\/\/domain.com\/r\/twitter-campaign",
    "list": "https:\/\/domain.com\/u\/admin\/twitter-campaign-3"
}
```

### Elimina campagna

CANCELLARE 
`https://urlkai.com/api/campaign/:id/delete`

Per eliminare una campagna, è necessario inviare una richiesta di ELIMINAZIONE.

```
curl --location --request DELETE 'https://urlkai.com/api/campaign/:id/delete' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'URL': 'https://urlkai.com/api/campaign/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/campaign/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/campaign/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "La campagna è stata eliminata con successo."
}
```

## Kanäle

Open in ChatGPT 

Open in Claude

### Elenca canali

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

Per ottenere i tuoi canali tramite l'API, puoi utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/channels?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/channels?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/channels?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channels?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "canali": [
            {
                "id": 1,
                "name": "Canale 1",
                "description": "Descrizione del canale 1",
                "colore": "#000000",
                "Stellato": vero
            },
            {
                "id": 2,
                "name": "Canale 2",
                "description": "Descrizione del canale 2",
                "color": "#FF0000",
                "stellato": falso
            }
        ]
    }
}
```

### Elencare gli elementi del canale

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

Per ottenere elementi in un canale selezionato tramite l'API, è possibile utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/channel/:id?limit=1&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id?limit=1&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/channel/:id?limit=1&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/channel/:id?limit=1&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channel/:id?limit=1&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "articoli": [
            {
                "type": "collegamenti",
                "id": 1,
                "title": "Il mio link di esempio",
                "anteprima": "https:\/\/google.com",
                "link": "https:\/\/urlkai.com\/google",
                "data": "2022-05-12"
            },
            {
                "tipo": "bio",
                "id": 1,
                "title": "Il mio esempio di biografia",
                "anteprima": "https:\/\/urlkai.com\/mybio",
                "link": "https:\/\/urlkai.com\/mybio",
                "data": "2022-06-01"
            }
        ]
    }
}
```

### Erstellen Sie einen Kanal

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

È possibile aggiungere un canale utilizzando questo endpoint.

| Parametro | Beschreibung |
| --- | --- |
| nome | (obbligatorio) Nome del canale |
| descrizione | (Facoltativo) Descrizione del canale |
| Colore | (Facoltativo) Colore del badge del canale (HEX) |
| Recitato | (Facoltativo) Contrassegnare il canale con o me(vero o falso) |

```
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

```
{
    "errore": 0,
    "id": 3,
    "nome": "Nuovo Canale",
    "Descrizione": "Il mio nuovo canale",
    "colore": "#000000",
    "con stella": vero
}
```

### Assegnazione di un elemento a un canale

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

Un articolo può essere assegnato a qualsiasi canale inviando una richiesta con l'ID del canale, il tipo di articolo (link, bio o qr) e l'ID dell'articolo.

| Parametro | Beschreibung |
| --- | --- |
| :ID canale | (obbligatorio) ID canale |
| :digitare | (obbligatorio) link o bio o qr |
| :iditemida | (obbligatorio) ID articolo |

```
curl --location --request POST 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'url': 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Elemento aggiunto al canale con successo."
}
```

### Kanal aktualisieren

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

Per aggiornare un canale, è necessario inviare dati validi in JSON tramite una richiesta PUT. I dati devoessere inviati come corpo grezzo della tua richiesta come mostrato di seguito. L'esempio seguente mostra tutti i parametri che puoi inviare ma non sei obbligato a inviarli tutti (vedi tabella per maggiori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| nome | (Facoltativo) Nome del canale |
| descrizione | (Facoltativo) Descrizione del canale |
| Colore | (Facoltativo) Colore del badge del canale (HEX) |
| Recitato | (Facoltativo) Contrassegnare il canale con o me(vero o falso) |

```
curl --location --request PUT 'https://urlkai.com/api/channel/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "name": "Acme Corp",
    "description": "canale per gli articoli per Acme Corp",
    "color": "#FFFFFF",
    "stellato": falso
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Acme Corp",
	    "description": "canale per gli articoli per Acme Corp",
	    "color": "#FFFFFF",
	    "stellato": falso
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'URL': 'https://urlkai.com/api/channel/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "name": "Acme Corp",
    "description": "canale per gli articoli per Acme Corp",
    "color": "#FFFFFF",
    "stellato": falso
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/channel/:id/update"
carico utile = {
    "name": "Acme Corp",
    "description": "canale per gli articoli per Acme Corp",
    "color": "#FFFFFF",
    "stellato": falso
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/channel/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "name": "Acme Corp",
    "description": "canale per gli articoli per Acme Corp",
    "color": "#FFFFFF",
    "stellato": falso
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il canale è stato aggiornato con successo."
}
```

### Elimina canale

CANCELLARE 
`https://urlkai.com/api/channel/:id/delete`

Per eliminare un canale, è necessario inviare una richiesta di ELIMINAZIONE. Anche tutti gli articoli non saranassegnati.

```
curl --location --request DELETE 'https://urlkai.com/api/channel/:id/delete' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/channel/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/channel/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/channel/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il canale è stato eliminato con successo."
}
```

## Konto

Open in ChatGPT 

Open in Claude

### Konto erhalten

OTTIENI 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/account',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/account"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "dati": {
        "id": 1,
        "e-mail": " [email protected] ",
        "username": "utente campione",
        "avatar": "https:\/\/domain.com\/content\/avatar.png",
        "status": "pro",
        "scade": "2022-11-15 15:00:00",
        "registrato": "2020-11-10 18:01:43"
    }
}
```

### Account aktualisieren

METTERE 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "e-mail": " [email protected] ",
    "password": "NewPassword1"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "e-mail": " [email protected] ",
	    "password": "NewPassword1"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'URL': 'https://urlkai.com/api/account/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "e-mail": " [email protected] ",
    "password": "NewPassword1"
}),
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/account/update"
carico utile = {
    "e-mail": " [email protected] ",
    "password": "NewPassword1"
}
headers = {
    'Authorization': 'Bearer YOURAPIKEY',
    'Content-Type': 'application/json'
}
response = requests.request("PUT", url, headers=headers, json=payload)
print(response.text)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/account/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "e-mail": " [email protected] ",
    "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

```
{
    "errore": 0,
    "message": "L'account è stato aggiornato con successo."
}
```

## Markendomänen

Open in ChatGPT 

Open in Claude

### Elenca i domini con marchio

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

Per ottenere i domini con il tuo marchio tramite l'API, puoi utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/domains?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domains?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/domains?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/domains?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/domains?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "domini": [
            {
                "id": 1,
                "dominio": "https:\/\/domain1.com",
                "redirectroot": "https:\/\/rootdomain.com",
                "redirect404": "https:\/\/rootdomain.com\/404"
            },
            {
                "id": 2,
                "dominio": "https:\/\/domain2.com",
                "redirectroot": "https:\/\/rootdomain2.com",
                "redirect404": "https:\/\/rootdomain2.com\/404"
            }
        ]
    }
}
```

### Crea un dominio con marchio

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

È possibile aggiungere un dominio utilizzando questo endpoint. Assicurati che il dominio sia puntato correttamente al nostro server.

| Parametro | Beschreibung |
| --- | --- |
| dominio | (obbligatorio) Dominio con marchio che include http o https |
| radice di reindirizzamento | (Facoltativo) Reindirizzamento root quando qualcuvisita il tuo dominio |
| reindirizzamento404 | (Facoltativo) Reindirizzamento 404 personalizzato |

```
curl --location --request POST 'https://urlkai.com/api/domain/add' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "dominio": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/add",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "dominio": "https:\/\/domain1.com",
	    "redirectroot": "https:\/\/rootdomain.com",
	    "redirect404": "https:\/\/rootdomain.com\/404"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'URL': 'https://urlkai.com/api/domain/add',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "dominio": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/domain/add"
carico utile = {
    "dominio": "https://domain1.com",
    "redirectroot": "https://rootdomain.com",
    "redirect404": "https://rootdomain.com/404"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = nuovo HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/domain/add");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "dominio": "https:\/\/domain1.com",
    "redirectroot": "https:\/\/rootdomain.com",
    "redirect404": "https:\/\/rootdomain.com\/404"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "id": 1
}
```

### Domäne aktualisieren

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

Per aggiornare un dominio brandizzato, è necessario inviare dati validi in JSON tramite una richiesta PUT. I dati devoessere inviati come corpo grezzo della tua richiesta come mostrato di seguito. L'esempio seguente mostra tutti i parametri che puoi inviare ma non sei obbligato a inviarli tutti (vedi tabella per maggiori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| radice di reindirizzamento | (Facoltativo) Reindirizzamento root quando qualcuvisita il tuo dominio |
| reindirizzamento404 | (Facoltativo) Reindirizzamento 404 personalizzato |

```
curl --location --request PUT 'https://urlkai.com/api/domain/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "redirectroot": "https:\/\/rootdomain-new.com",
	    "redirect404": "https:\/\/rootdomain-new.com\/404"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'URL': 'https://urlkai.com/api/domain/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/domain/:id/update"
carico utile = {
    "redirectroot": "https://rootdomain-new.com",
    "redirect404": "https://rootdomain-new.com/404"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/domain/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "redirectroot": "https:\/\/rootdomain-new.com",
    "redirect404": "https:\/\/rootdomain-new.com\/404"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il dominio è stato aggiornato correttamente."
}
```

### Elimina dominio

CANCELLARE 
`https://urlkai.com/api/domain/:id/delete`

Per eliminare un dominio, è necessario inviare una richiesta di DELETE.

```
curl --location --request DELETE 'https://urlkai.com/api/domain/:id/delete' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'URL': 'https://urlkai.com/api/domain/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/domain/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/domain/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il dominio è stato eliminato con successo."
}
```

## Pixel

Open in ChatGPT 

Open in Claude

### Elenco pixel

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

Per ottenere i codici dei pixel tramite l'API, puoi utilizzare questo endpoint. È inoltre possibile filtrare i dati (vedere la tabella per ulteriori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/pixels?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'url': 'https://urlkai.com/api/pixels?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/pixels?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/pixels?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "pixel": [
            {
                "id": 1,
                "tipo": "gtmpixel",
                "name": "GTM Pixel",
                "tag": "GA-123456789",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "tipo": "TwitterPixel",
                "name": "Pixel di Twitter",
                "tag": "1234567",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

### Crea un pixel

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

È possibile creare un pixel utilizzando questo endpoint. È necessario inviare il tipo di pixel e il tag.

| Parametro | Beschreibung |
| --- | --- |
| digitare | (obbligatorio) gtmpixel | gapixel | fbpixel | AdwordsPixel | Linkedinpixel | Pixel di Twitter | AdrollPixel | quorapixel | Pinterest | Bing | Snapchat | Reddit | tiktok |
| nome | (obbligatorio) Nome personalizzato per il tuo pixel |
| cartelli| (obbligatorio) Il tag per il pixel |

```
curl --location --request POST 'https://urlkai.com/api/pixel/add' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "tipo": "gtmpixel",
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/add",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "tipo": "gtmpixel",
	    "name": "Il mio GTM",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'url': 'https://urlkai.com/api/pixel/add',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "tipo": "gtmpixel",
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/pixel/add"
carico utile = {
    "tipo": "gtmpixel",
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = nuovo HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/pixel/add");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "tipo": "gtmpixel",
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "id": 1
}
```

### Pixel aktualisieren

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

Per aggiornare un pixel, è necessario inviare dati validi in JSON tramite una richiesta PUT. I dati devoessere inviati come corpo grezzo della tua richiesta come mostrato di seguito. L'esempio seguente mostra tutti i parametri che puoi inviare ma non sei obbligato a inviarli tutti (vedi tabella per maggiori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| nome | (Facoltativo) Nome personalizzato per il tuo pixel |
| cartelli| (obbligatorio) Il tag per il pixel |

```
curl --location --request PUT 'https://urlkai.com/api/pixel/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Il mio GTM",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'URL': 'https://urlkai.com/api/pixel/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/pixel/:id/update"
carico utile = {
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/pixel/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "name": "Il mio GTM",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il pixel è stato aggiornato correttamente".
}
```

### Elimina pixel

CANCELLARE 
`https://urlkai.com/api/pixel/:id/delete`

Per eliminare un pixel, è necessario inviare una richiesta di ELIMINAZIONE.

```
curl --location --request DELETE 'https://urlkai.com/api/pixel/:id/delete' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'URL': 'https://urlkai.com/api/pixel/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/pixel/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/pixel/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il pixel è stato eliminato con successo."
}
```

## Codici QR

Open in ChatGPT 

Open in Claude

### Elenca i codici QR

OTTIENI 
`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).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |

```
curl --location --request GET 'https://urlkai.com/api/qr?limit=2&page=1' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/qr?limit=2&page=1',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/qr?limit=2&page=1"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr?limit=2&page=1");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "QRS": [
            {
                "id": 2,
                "link": "https:\/\/urlkai.com\/qr\/a2d5e",
                "scansioni": 0,
                "name": "Google",
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "link": "https:\/\/urlkai.com\/qr\/b9edfe",
                "scansioni": 5,
                "name": "Google Canada",
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

### Holen Sie sich einen einzigen QR-Code

OTTIENI 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'url': 'https://urlkai.com/api/qr/:id',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/qr/:id"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr/:id");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "dettagli": {
        "id": 1,
        "link": "https:\/\/urlkai.com\/qr\/b9edfe",
        "scansioni": 5,
        "name": "Google Canada",
        "data": "2020-11-10 18:00:25"
    },
    "dati": {
        "clic": 1,
        "uniqueClicks": 1,
        "topCountries": {
            "Sconosciuto": "1"
        },
        "topReferrers": {
            "Diretto, email e altro": "1"
        },
        "topBrowsers": {
            "Chrome": "1"
        },
        "topOs": {
            "Windows 10": "1"
        },
        "socialCount": {
            "facebook": 0,
            "twitter": 0,
            "instagram": 0
        }
    }
}
```

### Erstellen Sie einen QR-Code

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

Per creare un codice QR, è necessario inviare dati validi in JSON tramite una richiesta POST. I dati devoessere inviati come corpo grezzo della tua richiesta come mostrato di seguito. L'esempio seguente mostra tutti i parametri che puoi inviare ma non sei obbligato a inviarli tutti (vedi tabella per maggiori informazioni).

| Parametro | Beschreibung |
| --- | --- |
| digitare | testo (obbligatorio) | vcard | collegamento | e-mail | telefo| sms | Connessione Wi-Fi |
| dati | (obbligatorio) Dati da incorporare all'interdel codice QR. I dati possoessere stringa o matrice a seconda del tipo |
| sfondo | (Facoltativo) Colore RGB, ad esempio rgb(255,255,255) |
| primo pia| (Facoltativo) Colore RGB, ad esempio rgb(0,0,0) |
| logo | (Facoltativo) Percorso del logo png o jpg |
| nome | (Facoltativo) Nome del codice QR |

```
curl --location --request POST 'https://urlkai.com/api/qr/add' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API del codice QR"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/add",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "type": "link",
	    "dati": "https:\/\/google.com",
	    "sfondo": "rgb(255,255,255)",
	    "primo piano": "rgb(0,0,0)",
	    "logo": "https:\/\/site.com\/logo.png",
	    "name": "API del codice QR"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'URL': 'https://urlkai.com/api/qr/add',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API del codice QR"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/qr/add"
carico utile = {
    "type": "link",
    "dati": "https://google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https://site.com/logo.png",
    "name": "API del codice QR"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/qr/add");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png",
    "name": "API del codice QR"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

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

### Aggiorna il codice QR

METTERE 
`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).

| Parametro | Beschreibung |
| --- | --- |
| dati | (obbligatorio) Dati da incorporare all'interdel codice QR. I dati possoessere stringa o matrice a seconda del tipo |
| sfondo | (Facoltativo) Colore RGB, ad esempio rgb(255,255,255) |
| primo pia| (Facoltativo) Colore RGB, ad esempio rgb(0,0,0) |
| logo | (Facoltativo) Percorso del logo png o jpg |

```
curl --location --request PUT 'https://urlkai.com/api/qr/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "type": "link",
	    "dati": "https:\/\/google.com",
	    "sfondo": "rgb(255,255,255)",
	    "primo piano": "rgb(0,0,0)",
	    "logo": "https:\/\/site.com\/logo.png"
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'url': 'https://urlkai.com/api/qr/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/qr/:id/update"
carico utile = {
    "type": "link",
    "dati": "https://google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https://site.com/logo.png"
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/qr/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "type": "link",
    "dati": "https:\/\/google.com",
    "sfondo": "rgb(255,255,255)",
    "primo piano": "rgb(0,0,0)",
    "logo": "https:\/\/site.com\/logo.png"
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il codice QR è stato aggiornato correttamente."
}
```

### Löschen Sie einen QR-Code

CANCELLARE 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'URL': 'https://urlkai.com/api/qr/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/qr/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/qr/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il codice QR è stato eliminato con successo."
}
```

## Verknüpfungen

Open in ChatGPT 

Open in Claude

### Elenca collegamenti

OTTIENI 
`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).

| Parametro | Beschreibung |
| --- | --- |
| limite | (Facoltativo) Risultato dei dati per pagina |
| pagina | (Facoltativo) Richiesta pagina corrente |
| ordine | (Facoltativo) Ordina i dati tra data o clic |
| corto | (Facoltativo) Cerca utilizzando l'URL breve. Si noti che quando si utilizza il parametro short, tutti gli altri parametri vengoignorati e se c'è una corrispondenza verrà restituita una risposta Single Link. |
| q | (Facoltativo) Cercare link utilizzando una parola chiave |

```
curl --location --request GET 'https://urlkai.com/api/urls?limit=2&page=1o=date' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/urls?limit=2&page=1o=date",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/urls?limit=2&page=1o=date',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/urls?limit=2&page=1o=date"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/urls?limit=2&page=1o=date");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": "0",
    "dati": {
        "risultato": 2,
        "perpage": 2,
        "currentpage": 1,
        "pagina successiva": 1,
        "maxpage": 1,
        "URL": [
            {
                "id": 2,
                "alias": "google",
                "shorturl": "https:\/\/urlkai.com\/google",
                "longurl": "https:\/\/google.com",
                "clic": 0,
                "title": "Google",
                "description": ","
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "alias": "googlecanada",
                "shorturl": "https:\/\/urlkai.com\/googlecanada",
                "longurl": "https:\/\/google.ca",
                "clic": 0,
                "title": "Google Canada",
                "description": ","
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

### Ottieni un singolo link

OTTIENI 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/:id",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "OTTIENI",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «GET»,
    'URL': 'https://urlkai.com/api/url/:id',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/url/:id"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("GET", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/url/:id");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "id": 1,
    "dettagli": {
        "id": 1,
        "shorturl": "https:\/\/urlkai.com\/googlecanada",
        "longurl": "https:\/\/google.com",
        "title": "Google",
        "description": ","
        "posizione": {
            "Canada": "https:\/\/google.ca",
            "Stati Uniti": "https:\/\/google.us"
        },
        "dispositivo": {
            "iphone": "https:\/\/google.com",
            "android": "https:\/\/google.com"
        },
        "scadenza": nullo,
        "data": "2020-11-10 18:01:43"
    },
    "dati": {
        "clic": 0,
        "uniqueClicks": 0,
        "topCountries": 0,
        "topReferrers": 0,
        "topBrowsers": 0,
        "topOs": 0,
        "socialCount": {
            "facebook": 0,
            "twitter": 0,
            "google": 0
        }
    }
}
```

### Einen Link kürzen

INSERISCI 
`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).

| Parametro | Beschreibung |
| --- | --- |
| URL | (obbligatorio) URL lungo da accorciare. |
| costume | (Facoltativo) Alias personalizzato invece di alias casuali. |
| digitare | (Facoltativo) Solo tipo di reindirizzamento [diretto, frame, splash] *Id* per una pagina iniziale personalizzata o *ID sovrapposizione* per le pagine CTA |
| parola d’ordine | (Facoltativo) Protezione con password |
| dominio | (Facoltativo) Dominio personalizzato |
| scadenza | (Facoltativo) Scadenza per l'esempio di collegamento 2021-09-28 23:11:16 |
| Obiettivo geografico | (Facoltativo) Dati di targeting geografico |
| DeviceTarget | (Facoltativo) Dati di targeting per dispositivo |
| languagetarget | (Facoltativo) Dati di targeting per lingua |
| metatitolo | (Facoltativo) Meta titolo |
| metadescrizione | (Facoltativo) Meta descrizione |
| metaimmagine | (Facoltativo) Collegamento a un'immagine jpg o png |
| descrizione | (Facoltativo) Nota o descrizione |
| Pixel | (Facoltativo) Matrice di ID pixel |
| canale | (Facoltativo) ID canale |
| campagna | (Facoltativo) ID campagna |
| collegamento diretto | (opzionale) Oggetto contenente link allo store dell'app. Quando si utilizza questo, è importante impostare anche il targeting dei dispositivi. (Nuovo) Ora puoi impostare il parametro "auto" su true per generare automaticamente i deep link dal long link fornito. |
| stato | (Facoltativo) *pubblico* o *privato (impostazione predefinita)* |

```
curl --location --request POST 'https://urlkai.com/api/url/add' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "url": "https:\/\/google.com",
    "status": "privato",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "metatitle": "Non Google",
    "metadescription": "Non descrizione di Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Per facebook",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "campagna": 1,
    "collegamento profondo": {
        "auto": vero,
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "Destinazione della lingua": [
        {
            "lingua": "en",
            "collegamento": "https:\/\/google.com"
        },
        {
            "lingua": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/add",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "status": "privato",
	    "personalizzato": "google",
	    "password": "mypass",
	    "scadenza": "2020-11-11 12:00:00",
	    "type": "splash",
	    "metatitle": "Non Google",
	    "metadescription": "Non descrizione di Google",
	    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
	    "description": "Per facebook",
	    "pixel": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canale": 1,
	    "campagna": 1,
	    "collegamento profondo": {
	        "auto": vero,
	        "mela": "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"
	    },
	    "Bersaglio geografico": [
	        {
	            "location": "Canada",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Stati Uniti",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "devicetarget": [
	        {
	            "device": "iPhone",
	            "collegamento": "https:\/\/google.com"
	        },
	        {
	            "device": "Android",
	            "collegamento": "https:\/\/google.com"
	        }
	    ],
	    "Destinazione della lingua": [
	        {
	            "lingua": "en",
	            "collegamento": "https:\/\/google.com"
	        },
	        {
	            "lingua": "fr",
	            "link": "https:\/\/google.ca"
	        }
	    ],
	    "parametri": [
	        {
	            "name": "aff",
	            "valore": "3"
	        },
	        {
	            "dispositivo": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «POST»,
    'URL': 'https://urlkai.com/api/url/add',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "url": "https:\/\/google.com",
    "status": "privato",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "metatitle": "Non Google",
    "metadescription": "Non descrizione di Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Per facebook",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "campagna": 1,
    "collegamento profondo": {
        "auto": vero,
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "Destinazione della lingua": [
        {
            "lingua": "en",
            "collegamento": "https:\/\/google.com"
        },
        {
            "lingua": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/url/add"
carico utile = {
    "url": "https://google.com",
    "status": "privato",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "metatitle": "Non Google",
    "metadescription": "Non descrizione di Google",
    "metaimage": "https://www.mozilla.org/media/protocol/img/logos/firefox/browser/og.4ad05d4125a5.png",
    "description": "Per facebook",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "campagna": 1,
    "collegamento profondo": {
        "auto": vero,
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https://google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https://google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "device": "Android",
            "link": "https://google.com"
        }
    ],
    "Destinazione della lingua": [
        {
            "lingua": "en",
            "link": "https://google.com"
        },
        {
            "lingua": "fr",
            "link": "https://google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("POST", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
richiesta var = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/url/add");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "status": "privato",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "metatitle": "Non Google",
    "metadescription": "Non descrizione di Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Per facebook",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "campagna": 1,
    "collegamento profondo": {
        "auto": vero,
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "Destinazione della lingua": [
        {
            "lingua": "en",
            "collegamento": "https:\/\/google.com"
        },
        {
            "lingua": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

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

### Link aktualisieren

METTERE 
`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).

| Parametro | Beschreibung |
| --- | --- |
| URL | (obbligatorio) URL lungo da accorciare. |
| costume | (Facoltativo) Alias personalizzato invece di alias casuali. |
| digitare | (Facoltativo) Tipo di reindirizzamento [diretto, fotogramma, splash] |
| parola d’ordine | (Facoltativo) Protezione con password |
| dominio | (Facoltativo) Dominio personalizzato |
| scadenza | (Facoltativo) Scadenza per l'esempio di collegamento 2021-09-28 23:11:16 |
| Obiettivo geografico | (Facoltativo) Dati di targeting geografico |
| DeviceTarget | (Facoltativo) Dati di targeting per dispositivo |
| languagetarget | (Facoltativo) Dati di targeting per lingua |
| metatitolo | (Facoltativo) Meta titolo |
| metadescrizione | (Facoltativo) Meta descrizione |
| metaimmagine | (Facoltativo) Collegamento a un'immagine jpg o png |
| Pixel | (Facoltativo) Matrice di ID pixel |
| canale | (Facoltativo) ID canale |
| campagna | (Facoltativo) ID campagna |
| collegamento diretto | (Facoltativo) Oggetto contenente collegamenti all'app store. Quando si utilizza questa opzione, è importante impostare anche il targeting per dispositivo. |

```
curl --location --request PUT 'https://urlkai.com/api/url/:id/update' \
--header 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
--dati-grezzi '{
    "url": "https:\/\/google.com",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "collegamento profondo": {
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/:id/update",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "personalizzato": "google",
	    "password": "mypass",
	    "scadenza": "2020-11-11 12:00:00",
	    "type": "splash",
	    "pixel": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canale": 1,
	    "collegamento profondo": {
	        "mela": "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"
	    },
	    "Bersaglio geografico": [
	        {
	            "location": "Canada",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Stati Uniti",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "devicetarget": [
	        {
	            "device": "iPhone",
	            "collegamento": "https:\/\/google.com"
	        },
	        {
	            "device": "Android",
	            "collegamento": "https:\/\/google.com"
	        }
	    ],
	    "parametri": [
	        {
	            "name": "aff",
	            "valore": "3"
	        },
	        {
	            "dispositivo": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    «metodo»: «PUT»,
    'URL': 'https://urlkai.com/api/url/:id/update',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    corpo: JSON.stringify({
    "url": "https:\/\/google.com",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "collegamento profondo": {
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/url/:id/update"
carico utile = {
    "url": "https://google.com",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "collegamento profondo": {
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https://google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https://google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "device": "Android",
            "link": "https://google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("PUT", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/url/:id/update");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "personalizzato": "google",
    "password": "mypass",
    "scadenza": "2020-11-11 12:00:00",
    "type": "splash",
    "pixel": [
        1,
        2,
        3,
        4
    ],
    "canale": 1,
    "collegamento profondo": {
        "mela": "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"
    },
    "Bersaglio geografico": [
        {
            "location": "Canada",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Stati Uniti",
            "link": "https:\/\/google.us"
        }
    ],
    "devicetarget": [
        {
            "device": "iPhone",
            "collegamento": "https:\/\/google.com"
        },
        {
            "device": "Android",
            "collegamento": "https:\/\/google.com"
        }
    ],
    "parametri": [
        {
            "name": "aff",
            "valore": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

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

### Link löschen

CANCELLARE 
`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 'Autorizzazione: Portatore YOURAPIKEY' \
--header 'Tipo di contenuto: application/json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/:id/delete",
    CURLOPT_RETURNTRANSFER => vero,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_FOLLOWLOCATION => vero,
    CURLOPT_CUSTOMREQUEST => "ELIMINA",
    CURLOPT_HTTPHEADER => [
        "Autorizzazione: Portatore YOURAPIKEY",
        "Tipo di contenuto: applicazione/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var request = require('richiesta');
opzioni var = {
    'method': 'DELETE',
    'URL': 'https://urlkai.com/api/url/:id/delete',
    'intestazioni': {
        «Autorizzazione»: «Bearer YOURAPIKEY»,
        'Tipo di contenuto': 'applicazione/json'
    },
    
};
request(opzioni, funzione (errore, risposta) {
    if (error) throw new Error(error);
    console.log(response.body);
});
```

```
Richieste di importazione
url = "https://urlkai.com/api/url/:id/delete"
payload = {}
intestazioni = {
    «Autorizzazione»: «Bearer YOURAPIKEY»,
    'Tipo di contenuto': 'applicazione/json'
}
risposta = requests.request("DELETE", url, headers=headers, json=payload)
print(risposta.testo)
```

```
var client = nuovo HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/url/:id/delete");
richiesta. Headers.Add("Autorizzazione", "Portatore YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
richiesta. Contenuto = contenuto;
risposta var = attendere il client. SendAsync(richiesta);
risposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

#### Antwort des Servers

```
{
    "errore": 0,
    "message": "Il link è stato eliminato con successo"
}
```