# Developers
**Source:** https://pt.urlkai.com/fr/developers
**Language:** Brazilian Portuguese

---

Iniciante 

Autenticação 

Limite de débit 

Gestion des réponses 

###### Campagnes

Listar campanhas 

Créer une campagne 

Atribuir um link a uma campanha 

Mettre à jour la campagne 

Excluir campanha

###### Canaux

Listar canais 

Listar itens de canal 

Créer une chaîne 

Atribuir um item a um canal 

Mettre à jour la chaîne 

Excluir canal

###### Códigos QR

Listar códigos QR 

Obtenez un seul code QR 

Créer un code QR 

Atualizar QR Code 

Supprimer un code QR

###### Compte

Obtenir un compte 

Compte mis à jour

###### Domaines de marque

Listar domínios de marca 

Criar um domínio de marca 

Mettre à jour le domaine 

Excluir domínio

###### Arquivos

Arquivos de Lista 

Faça upload de um arquivo

###### Laços

Links da lista 

Obtenha um único link 

Raccourcir un lien 

Mettre à jour le lien 

Supprimer un lien

###### Pixels

Listar pixels 

Criar um pixel 

Mettre à jour le pixel 

Excluir pixel

###### Splash personnalisé

Listar Splash personalizado

###### Sobreposições CTA

Listar sobreposições de CTA

#### Référence API pour les développeurs

###### Iniciante

Une clé API est requise pour que les demandes soient traitées par le système. Une fois qu'un utilisateur s'inscrit, une clé API est automatiquement générée pour cet utilisateur. La clé API doit être envoyée avec chaque requête (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, il y aura une erreur. Assurez-vous de garder votre clé API secrète pour éviter les abus.

###### Autenticação

Pour vous authentifier auprès du système API, vous devez envoyer votre clé API en tant que jeton d'autorisation avec chaque demande. Vous pouvez voir un exemple de code ci-dessous.

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/account' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
));

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/account',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: ''
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/account"
carga = {}
cabeçalhos = {
  'Autorização': 'Portador YOURAPIKEY',
  'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Limite de débit

Notre API dispose d'un limiteur de débit pour se protéger contre les pics de demandes afin de maximiser sa stabilité. Notre limiteur de débit est actuellement limité à 30 requêtes par 1 minute. Observe que a tarifa pode mudar de acordo com o plaassinado.

Plusieurs en-têtes seront envoyés avec la réponse et ceux-ci peuvent être examinés pour déterminer diverses informations sur la demande.

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

###### Gestion des réponses

Toutes les réponses de l'API sont renvoyées au format JSON par défaut. Pour convertir cela en données utilisables, la fonction appropriée devra être utilisée en fonction de la langue. En PHP, la fonction json\_decode() peut être utilisée pour convertir les données en objet (par défaut) ou en tableau (définissez le deuxième paramètre sur true). Il est très important de vérifier la clé d'erreur car elle indique s'il y a eu une erreur ou non. Vous pouvez également vérifier le code d'en-tête.

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

---

#### Campagnes - Open in ChatGPT - Open in Claude

###### Listar campanhas

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

Para obter suas campanhas por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/campaigns?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaigns?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/campaigns?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/campaigns?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/campaigns?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "campanhas": [
            {
                "id": 1,
                "name": "Exemplo de campanha",
                "público": falso,
                "rotator": false,
                "lista": "https:\/\/domain.com\/u\/admin\/list-1"
            },
            {
                "id": 2,
                "domain": "Campanha do Facebook",
                "público": verdadeiro,
                "rotador": "https:\/\/domain.com\/r\/test",
                "lista": "https:\/\/domain.com\/u\/admin\/test-2"
            }
        ]
    }
}
```

###### Créer une campagne

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

Uma campanha pode ser adicionada usando esse endpoint.

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (opcional) Nome da campanha |
| lesma | (opcional) Lesma Rotadora |
| público | (opcional) Acesso |

cURL
PHP
Node.js
Python
C#

```
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());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "id": 3,
    "domínio": "Nova Campanha",
    "Público": Verdade,
    "rotador": "https:\/\/domain.com\/r\/new-campaign",
    "lista": "https:\/\/domain.com\/u\/admin\/new-campaign-3"
}
```

###### Atribuir um link a uma campanha

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

Um link curto pode ser atribuído a uma campanha usando esse endpoint. O endpoint requer o ID da campanha e o ID do link curto.

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:campaignid/assign/:linkid",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/campaign/:campaignid/assign/:linkid',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/campaign/:campaignid/assign/:linkid"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/campaign/:campaignid/assign/:linkid");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "Link adicionado com sucesso à campanha."
}
```

###### Mettre à jour la campagne

PÔR  `https://urlkai.com/api/campaign/:id/update`

Para atualizar uma campanha, você precisa enviar dados válidos em JSON por meio de uma solicitação PUT. Os dados devem ser enviados como o corpo bruto de sua solicitação, conforme mostrado abaixo. O exemplo abaixo mostra todos os parâmetros que você pode enviar, mas não é obrigado a enviar todos (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (obrigatório) Nome da campanha |
| lesma | (opcional) Lesma Rotadora |
| público | (opcional) Acesso |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/campaign/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "name": "Campanha do Twitter",
    "slug": "campanha do twitter",
    "público": verdadeiro
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Campanha do Twitter",
	    "slug": "campanha do twitter",
	    "público": verdadeiro
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/campaign/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "name": "Campanha do Twitter",
    "slug": "campanha do twitter",
    "público": verdadeiro
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/campaign/:id/update"
carga = {
    "name": "Campanha do Twitter",
    "slug": "campanha do twitter",
    "público": verdadeiro
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/campaign/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "name": "Campanha do Twitter",
    "slug": "campanha do twitter",
    "público": verdadeiro
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "id": 3,
    "domain": "Campanha do Twitter",
    "público": verdadeiro,
    "rotator": "https:\/\/domain.com\/r\/twitter-campaign",
    "lista": "https:\/\/domain.com\/u\/admin\/twitter-campaign-3"
}
```

###### Excluir campanha

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

Para excluir uma campanha, você precisa enviar uma solicitação DELETE.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/campaign/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/campaign/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/campaign/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/campaign/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/campaign/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "A campanha foi excluída com sucesso."
}
```

---

#### Canaux - Open in ChatGPT - Open in Claude

###### Listar canais

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

Para obter seus canais por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/channels?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/channels?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/channels?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channels?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "canais": [
            {
                "id": 1,
                "name": "Canal 1",
                "description": "Descrição do canal 1",
                "cor": "#000000",
                "Estrelado": Verdadeiro
            },
            {
                "id": 2,
                "name": "Canal 2",
                "description": "Descrição do canal 2",
                "cor": "#FF0000",
                "estrelado": falso
            }
        ]
    }
}
```

###### Listar itens de canal

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

Para obter itens em um canal selecionado por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/channel/:id?limit=1&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id?limit=1&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/channel/:id?limit=1&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/channel/:id?limit=1&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/channel/:id?limit=1&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "itens": [
            {
                "tipo": "links",
                "id": 1,
                "title": "Meu link de amostra",
                "visualização": "https:\/\/google.com",
                "link": "https:\/\/urlkai.com\/google",
                "data": "2022-05-12"
            },
            {
                "tipo": "bio",
                "id": 1,
                "title": "Minha biografia de amostra",
                "visualização": "https:\/\/urlkai.com\/mybio",
                "link": "https:\/\/urlkai.com\/mybio",
                "data": "01/06/2022"
            }
        ]
    }
}
```

###### Créer une chaîne

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

Um canal pode ser adicionado usando esse ponto de extremidade.

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (obrigatório) Nome do canal |
| descrição | (opcional) Descrição do canal |
| Cor | (opcional) Cor do emblema do canal (HEX) |
| Estrelou | (opcional) Marcar o canal com estrela ou não (verdadeiro ou falso) |

cURL
PHP
Node.js
Python
C#

```
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());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "id": 3,
    "nome": "Novo Canal",
    "Descrição": "Meu Novo Canal",
    "cor": "#000000",
    "estrelado": verdade
}
```

###### Atribuir um item a um canal

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

Um item pode ser atribuído a qualquer canal enviando uma solicitação com o ID do canal, tipo de item (links, biografia ou qr) e ID do item.

| **Paramètre** | **La descrição** |
| --- | --- |
| :ID do canal | (obrigatório) ID do canal |
| :tipo | (obrigatório) links ou biografia ou QR |
| :itemid | (obrigatório) Item ID |

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/channel/:channelid/assign/:type/:itemid',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/channel/:channelid/assign/:type/:itemid");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "Item adicionado com sucesso ao canal."
}
```

###### Mettre à jour la chaîne

PÔR  `https://urlkai.com/api/channel/:id/update`

Para atualizar um canal, você precisa enviar dados válidos em JSON por meio de uma solicitação PUT. Os dados devem ser enviados como o corpo bruto de sua solicitação, conforme mostrado abaixo. O exemplo abaixo mostra todos os parâmetros que você pode enviar, mas não é obrigado a enviar todos (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (opcional) Nome do canal |
| descrição | (opcional) Descrição do canal |
| Cor | (opcional) Cor do emblema do canal (HEX) |
| Estrelou | (opcional) Marcar o canal com estrela ou não (verdadeiro ou falso) |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/channel/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "name": "Acme Corp",
    "description": "canal para itens para a Acme Corp",
    "cor": "#FFFFFF",
    "estrelado": falso
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Acme Corp",
	    "description": "canal para itens para a Acme Corp",
	    "cor": "#FFFFFF",
	    "estrelado": falso
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/channel/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "name": "Acme Corp",
    "description": "canal para itens para a Acme Corp",
    "cor": "#FFFFFF",
    "estrelado": falso
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/channel/:id/update"
carga = {
    "name": "Acme Corp",
    "description": "canal para itens para a Acme Corp",
    "cor": "#FFFFFF",
    "estrelado": falso
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/channel/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "name": "Acme Corp",
    "description": "canal para itens para a Acme Corp",
    "cor": "#FFFFFF",
    "estrelado": falso
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O canal foi atualizado com sucesso."
}
```

###### Excluir canal

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

Para excluir um canal, você precisa enviar uma solicitação DELETE. Todos os itens também serão não atribuídos.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/channel/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/channel/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/channel/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/channel/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/channel/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O canal foi excluído com sucesso."
}
```

---

#### Códigos QR - Open in ChatGPT - Open in Claude

###### Listar códigos QR

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

Pour obtenir vos codes QR via l'API, vous pouvez utiliser ce point de terminaison. Vous pouvez également filtrer les données (voir le tableau pour plus d'informations).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/qr?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/qr?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/qr?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "qrs": [
            {
                "id": 2,
                "link": "https:\/\/urlkai.com\/qr\/a2d5e",
                "varreduras": 0,
                "name": "Google",
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "link": "https:\/\/urlkai.com\/qr\/b9edfe",
                "varreduras": 5,
                "name": "Google Canadá",
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

###### Obtenez un seul code QR

OBTER  `https://urlkai.com/api/qr/:id`

Pour obtenir les détails d'un seul code QR via l'API, vous pouvez utiliser ce point de terminaison.

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/qr/:id' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/qr/:id',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/qr/:id"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/qr/:id");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "detalhes": {
        "id": 1,
        "link": "https:\/\/urlkai.com\/qr\/b9edfe",
        "varreduras": 5,
        "name": "Google Canadá",
        "data": "2020-11-10 18:00:25"
    },
    "dados": {
        "cliques": 1,
        "uniqueClicks": 1,
        "topCountries": {
            "Desconhecido": "1"
        },
        "topReferrers": {
            "Direto, e-mail e outros": "1"
        },
        "topBrowsers": {
            "Chrome": "1"
        },
        "topOs": {
            "Windows 10": "1"
        },
        "socialCount": {
            "facebook": 0,
            "twitter": 0,
            "Instagram": 0
        }
    }
}
```

###### Créer un code QR

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

Para criar um QR Code, você precisa enviar um dado válido em JSON por meio de uma solicitação POST. Os dados devem ser enviados como o corpo bruto de sua solicitação, conforme mostrado abaixo. O exemplo abaixo mostra todos os parâmetros que você pode enviar, mas não é obrigado a enviar todos (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| tipo | (obrigatório) texto | vcard | ligação | E-mail | telefone | sms | Wi-Fi |
| dados | (obrigatório) Dados a serem incorporados dentro do código QR. Os dados podem ser string ou array, dependendo do tipo |
| fundo | (opcional) Cor RGB, por exemplo, rgb (255.255.255) |
| primeiro pla| (opcional) Cor RGB, por exemplo, rgb(0,0,0) |
| logotipo | (opcional) Caminho para o logotipo png ou jpg |
| nome | (opcional) Nome do código QR |

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/qr/add' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png",
    "name": "API de código QR"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/add",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "tipo": "link",
	    "dados": "https:\/\/google.com",
	    "background": "rgb(255,255,255)",
	    "primeiro plano": "rgb(0,0,0)",
	    "logotipo": "https:\/\/site.com\/logo.png",
	    "name": "API de código QR"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/qr/add',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png",
    "name": "API de código QR"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/qr/add"
carga = {
    "tipo": "link",
    "dados": "https://google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logo": "https://site.com/logo.png",
    "name": "API de código QR"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/qr/add");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png",
    "name": "API de código QR"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Atualizar QR Code

PÔR  `https://urlkai.com/api/qr/:id/update`

Pour mettre à jour un QR Code, vous devez envoyer une donnée valide au format JSON via une requête PUT. Les données doivent être envoyées en tant que corps brut de votre demande, comme indiqué ci-dessous. L'exemple ci-dessous montre tous les paramètres que vous pouvez envoyer mais vous n'êtes pas obligé de tous les envoyer (voir le tableau pour plus d'informations).

| **Paramètre** | **La descrição** |
| --- | --- |
| dados | (obrigatório) Dados a serem incorporados dentro do código QR. Os dados podem ser string ou array, dependendo do tipo |
| fundo | (opcional) Cor RGB, por exemplo, rgb (255.255.255) |
| primeiro pla| (opcional) Cor RGB, por exemplo, rgb(0,0,0) |
| logotipo | (opcional) Caminho para o logotipo png ou jpg |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/qr/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "tipo": "link",
	    "dados": "https:\/\/google.com",
	    "background": "rgb(255,255,255)",
	    "primeiro plano": "rgb(0,0,0)",
	    "logotipo": "https:\/\/site.com\/logo.png"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/qr/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/qr/:id/update"
carga = {
    "tipo": "link",
    "dados": "https://google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https://site.com/logo.png"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/qr/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "tipo": "link",
    "dados": "https:\/\/google.com",
    "background": "rgb(255,255,255)",
    "primeiro plano": "rgb(0,0,0)",
    "logotipo": "https:\/\/site.com\/logo.png"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O QR foi atualizado com sucesso."
}
```

###### Supprimer un code QR

EXCLUIR  `https://urlkai.com/api/qr/:id/delete`

Pour supprimer un code QR, vous devez envoyer une demande DELETE.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/qr/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/qr/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/qr/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/qr/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/qr/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O QR Code foi excluído com sucesso."
}
```

---

#### Compte - Open in ChatGPT - Open in Claude

###### Obtenir un compte

OBTER  `https://urlkai.com/api/account`

Pour obtenir des informations sur le compte, vous pouvez envoyer une demande à ce point de terminaison et il renverra des données sur le compte.

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/account' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/account',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/account"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/account");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "dados": {
        "id": 1,
        "e-mail": " [email protegido] ",
        "nome de usuário": "sampleuser",
        "avatar": "https:\/\/domain.com\/content\/avatar.png",
        "status": "pro",
        "expira": "2022-11-15 15:00:00",
        "registrado": "2020-11-10 18:01:43"
    }
}
```

###### Compte mis à jour

PÔR  `https://urlkai.com/api/account/update`

Pour mettre à jour les informations sur le compte, vous pouvez envoyer une demande à ce point de terminaison et il mettra à jour les données sur le compte.

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/account/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "e-mail": " [email protegido] ",
    "senha": "novasenha"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/account/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "e-mail": " [email protegido] ",
	    "senha": "novasenha"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/account/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "e-mail": " [email protegido] ",
    "senha": "novasenha"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/account/update"
carga = {
    "e-mail": " [email protegido] ",
    "senha": "novasenha"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/account/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "e-mail": " [email protegido] ",
    "senha": "novasenha"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "A conta foi atualizada com sucesso."
}
```

---

#### Domaines de marque - Open in ChatGPT - Open in Claude

###### Listar domínios de marca

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

Para obter seus domínios de marca por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/domains?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domains?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/domains?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/domains?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/domains?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "domínios": [
            {
                "id": 1,
                "domínio": "https:\/\/domain1.com",
                "raiz de redirecionamento": "https:\/\/rootdomain.com",
                "redirecionamento404": "https:\/\/rootdomain.com\/404"
            },
            {
                "id": 2,
                "domínio": "https:\/\/domain2.com",
                "raiz de redirecionamento": "https:\/\/rootdomain2.com",
                "redirect404": "https:\/\/rootdomain2.com\/404"
            }
        ]
    }
}
```

###### Criar um domínio de marca

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

Um domínio pode ser adicionado usando esse ponto de extremidade. Certifique-se de que o domínio esteja apontado corretamente para o nosso servidor.

| **Paramètre** | **La descrição** |
| --- | --- |
| domínio | (obrigatório) Domínio de marca, incluindo http ou https |
| raiz de redirecionamento | (opcional) Redirecionamento raiz quando alguém visita seu domínio |
| redirecionamento404 | (opcional) Redirecionamento 404 personalizado |

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/domain/add' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "domínio": "https:\/\/domain1.com",
    "raiz de redirecionamento": "https:\/\/rootdomain.com",
    "redirecionamento404": "https:\/\/rootdomain.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/add",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "domínio": "https:\/\/domain1.com",
	    "raiz de redirecionamento": "https:\/\/rootdomain.com",
	    "redirecionamento404": "https:\/\/rootdomain.com\/404"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/domain/add',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "domínio": "https:\/\/domain1.com",
    "raiz de redirecionamento": "https:\/\/rootdomain.com",
    "redirecionamento404": "https:\/\/rootdomain.com\/404"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/domain/add"
carga = {
    "domínio": "https://domain1.com",
    "redirectroot": "https://rootdomain.com",
    "redirect404": "https://rootdomain.com/404"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/domain/add");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "domínio": "https:\/\/domain1.com",
    "raiz de redirecionamento": "https:\/\/rootdomain.com",
    "redirecionamento404": "https:\/\/rootdomain.com\/404"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Mettre à jour le domaine

PÔR  `https://urlkai.com/api/domain/:id/update`

Para atualizar um domínio de marca, você precisa enviar dados válidos em JSON por meio de uma solicitação PUT. Os dados devem ser enviados como o corpo bruto de sua solicitação, conforme mostrado abaixo. O exemplo abaixo mostra todos os parâmetros que você pode enviar, mas não é obrigado a enviar todos (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| raiz de redirecionamento | (opcional) Redirecionamento raiz quando alguém visita seu domínio |
| redirecionamento404 | (opcional) Redirecionamento 404 personalizado |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/domain/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "raiz de redirecionamento": "https:\/\/rootdomain-new.com",
    "redirecionamento404": "https:\/\/rootdomain-new.com\/404"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "raiz de redirecionamento": "https:\/\/rootdomain-new.com",
	    "redirecionamento404": "https:\/\/rootdomain-new.com\/404"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/domain/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "raiz de redirecionamento": "https:\/\/rootdomain-new.com",
    "redirecionamento404": "https:\/\/rootdomain-new.com\/404"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/domain/:id/update"
carga = {
    "redirectroot": "https://rootdomain-new.com",
    "redirect404": "https://rootdomain-new.com/404"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/domain/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "raiz de redirecionamento": "https:\/\/rootdomain-new.com",
    "redirecionamento404": "https:\/\/rootdomain-new.com\/404"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O domínio foi atualizado com sucesso."
}
```

###### Excluir domínio

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

Para excluir um domínio, você precisa enviar uma solicitação DELETE.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/domain/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/domain/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/domain/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/domain/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/domain/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O domínio foi excluído com sucesso."
}
```

---

#### Arquivos - Open in ChatGPT - Open in Claude

###### Arquivos de Lista

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

Pegue todos os seus arquivos. Você também pode pesquisar pelo nome.

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (opcional) Procure um arquivo pelo nome |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
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());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Faça upload de um arquivo

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

Faça upload de um arquivo enviando os dados binários como corpo do post. Você precisa enviar o nome do arquivo incluindo a extensão em vez de :filename na URL (por exemplo, brandkit.zip). Você pode definir opções enviando os seguintes parâmetros.

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (opcional) Nome do arquivo |
| costume | (opcional) Alias personalizado em vez de alias aleatório. |
| domínio | (opcional) Domínio personalizado |
| senha | (opcional) Proteção por senha |
| caducidade | (opcional) Expiração do exemplo de download 2021-09-28 |
| maxdownloads | (opcional) Número máximo de downloads |

cURL
PHP
Node.js
Python
C#

```
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());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

---

#### Laços - Open in ChatGPT - Open in Claude

###### Links da lista

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

Pour obtenir vos liens via l'API, vous pouvez utiliser ce point de terminaison. Vous pouvez également filtrer les données (voir le tableau pour plus d'informations).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |
| ordem | (opcional) Classificar dados entre data ou clique |
| curto | (opcional) Pesquise usando o url curto. Observe que, quando você usa o parâmetro short, todos os outros parâmetros são ignorados e, se houver uma correspondência, uma resposta de link único será retornada. |
| q | (opcional) Pesquisar links usando uma palavra-chave |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/urls?limit=2&page=1o=date' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/urls?limit=2&page=1o=date",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/urls?limit=2&page=1o=date',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/urls?limit=2&page=1o=date"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/urls?limit=2&page=1o=date");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "urls": [
            {
                "id": 2,
                "alias": "google",
                "shorturl": "https:\/\/urlkai.com\/google",
                "longurl": "https:\/\/google.com",
                "cliques": 0,
                "title": "Google",
                "description": "",
                "data": "2020-11-10 18:01:43"
            },
            {
                "id": 1,
                "alias": "googlecanada",
                "shorturl": "https:\/\/urlkai.com\/googlecanada",
                "longurl": "https:\/\/google.ca",
                "cliques": 0,
                "title": "Google Canadá",
                "description": "",
                "data": "2020-11-10 18:00:25"
            }
        ]
    }
}
```

###### Obtenha um único link

OBTER  `https://urlkai.com/api/url/:id`

Pour obtenir les détails d'un seul lien via l'API, vous pouvez utiliser ce point de terminaison.

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/url/:id' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/:id",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/url/:id',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/url/:id"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/url/:id");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "id": 1,
    "detalhes": {
        "id": 1,
        "shorturl": "https:\/\/urlkai.com\/googlecanada",
        "longurl": "https:\/\/google.com",
        "title": "Google",
        "description": "",
        "localização": {
            "Canadá": "https:\/\/google.ca",
            "Estados Unidos": "https:\/\/google.us"
        },
        "dispositivo": {
            "iphone": "https:\/\/google.com",
            "android": "https:\/\/google.com"
        },
        "expiração": nulo,
        "data": "2020-11-10 18:01:43"
    },
    "dados": {
        "cliques": 0,
        "uniqueClicks": 0,
        "topCountries": 0,
        "topReferrers": 0,
        "topBrowsers": 0,
        "topOs": 0,
        "socialCount": {
            "facebook": 0,
            "twitter": 0,
            "google": 0
        }
    }
}
```

###### Raccourcir un lien

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

Pour raccourcir un lien, vous devez envoyer une donnée valide en JSON via une requête POST. Les données doivent être envoyées en tant que corps brut de votre demande, comme indiqué ci-dessous. L'exemple ci-dessous montre tous les paramètres que vous pouvez envoyer mais vous n'êtes pas obligé de tous les envoyer (voir le tableau pour plus d'informations).

| **Paramètre** | **La descrição** |
| --- | --- |
| URL | (obrigatório) URL longo para encurtar. |
| costume | (opcional) Alias personalizado em vez de alias aleatório. |
| tipo | (opcional) Tipo de redirecionamento [direto, quadro, splash], apenas *id* para página inicial personalizada ou *ID de sobreposição* Para páginas CTA |
| senha | (opcional) Proteção por senha |
| domínio | (opcional) Domínio personalizado |
| caducidade | (opcional) Expiração para o exemplo de link 2021-09-28 23:11:16 |
| Segmentação geográfica | (opcional) Dados de segmentação geográfica |
| alvo do dispositivo | (opcional) Dados de segmentação por dispositivo |
| IdiomaAlvo | (opcional) Dados de segmentação por idioma |
| metatítulo | (opcional) Meta título |
| Metadescrição | (opcional) Meta descrição |
| meta-imagem | (opcional) Link para uma imagem jpg ou png |
| descrição | (opcional) Nota ou descrição |
| Pixels | (opcional) Matriz de IDs de pixel |
| canal | (opcional) ID do canal |
| campanha | (opcional) ID da campanha |
| link direto | (opcional) Objeto contendo links da loja de aplicativos. Ao usar isso, é importante definir também o direcionamento do dispositivo. (Novo) Agora você pode definir o parâmetro "auto" para true para gerar automaticamente os links profundos a partir do long link fornecido. |
| estado | (opcional) *público* ou *privado (padrão)* |

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/url/add' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "url": "https:\/\/google.com",
    "status": "privado",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "metatitle": "Não é Google",
    "metadescription": "Não é uma descrição do Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Para o facebook",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanha": 1,
    "deeplink": {
        "auto": true,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "língua": "en",
            "link": "https:\/\/google.com"
        },
        {
            "idioma": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/add",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "status": "privado",
	    "personalizado": "google",
	    "password": "mypass",
	    "expiração": "2020-11-11 12:00:00",
	    "tipo": "respingo",
	    "metatitle": "Não é Google",
	    "metadescription": "Não é uma descrição do Google",
	    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
	    "description": "Para o facebook",
	    "pixels": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canal": 1,
	    "campanha": 1,
	    "deeplink": {
	        "auto": true,
	        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
	        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
	    },
	    "alvo geográfico": [
	        {
	            "location": "Canadá",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Estados Unidos",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "Destido dispositivo": [
	        {
	            "device": "iPhone",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "dispositivo": "Android",
	            "link": "https:\/\/google.com"
	        }
	    ],
	    "languagetarget": [
	        {
	            "língua": "en",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "idioma": "fr",
	            "link": "https:\/\/google.ca"
	        }
	    ],
	    "parâmetros": [
	        {
	            "nome": "aff",
	            "valor": "3"
	        },
	        {
	            "dispositivo": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/url/add',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "url": "https:\/\/google.com",
    "status": "privado",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "metatitle": "Não é Google",
    "metadescription": "Não é uma descrição do Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Para o facebook",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanha": 1,
    "deeplink": {
        "auto": true,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "língua": "en",
            "link": "https:\/\/google.com"
        },
        {
            "idioma": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/url/add"
carga = {
    "url": "https://google.com",
    "status": "privado",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "metatitle": "Não é Google",
    "metadescription": "Não é uma descrição do Google",
    "metaimage": "https://www.mozilla.org/media/protocol/img/logos/firefox/browser/og.4ad05d4125a5.png",
    "description": "Para o facebook",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanha": 1,
    "deeplink": {
        "auto": true,
        "maçã": "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"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https://google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https://google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https://google.com"
        }
    ],
    "languagetarget": [
        {
            "língua": "en",
            "link": "https://google.com"
        },
        {
            "idioma": "fr",
            "link": "https://google.ca"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/url/add");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "status": "privado",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "metatitle": "Não é Google",
    "metadescription": "Não é uma descrição do Google",
    "metaimage": "https:\/\/www.mozilla.org\/media\/protocol\/img\/logos\/firefox\/browser\/og.4ad05d4125a5.png",
    "description": "Para o facebook",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "campanha": 1,
    "deeplink": {
        "auto": true,
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "languagetarget": [
        {
            "língua": "en",
            "link": "https:\/\/google.com"
        },
        {
            "idioma": "fr",
            "link": "https:\/\/google.ca"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Mettre à jour le lien

PÔR  `https://urlkai.com/api/url/:id/update`

Pour mettre à jour un lien, vous devez envoyer une donnée valide en JSON via une requête PUT. Les données doivent être envoyées en tant que corps brut de votre demande, comme indiqué ci-dessous. L'exemple ci-dessous montre tous les paramètres que vous pouvez envoyer mais vous n'êtes pas obligé de tous les envoyer (voir le tableau pour plus d'informations).

| **Paramètre** | **La descrição** |
| --- | --- |
| URL | (obrigatório) URL longo para encurtar. |
| costume | (opcional) Alias personalizado em vez de alias aleatório. |
| tipo | (opcional) Tipo de redirecionamento [direto, quadro, respingo] |
| senha | (opcional) Proteção por senha |
| domínio | (opcional) Domínio personalizado |
| caducidade | (opcional) Expiração para o exemplo de link 2021-09-28 23:11:16 |
| Segmentação geográfica | (opcional) Dados de segmentação geográfica |
| alvo do dispositivo | (opcional) Dados de segmentação por dispositivo |
| IdiomaAlvo | (opcional) Dados de segmentação por idioma |
| metatítulo | (opcional) Meta título |
| Metadescrição | (opcional) Meta descrição |
| meta-imagem | (opcional) Link para uma imagem jpg ou png |
| Pixels | (opcional) Matriz de IDs de pixel |
| canal | (opcional) ID do canal |
| campanha | (opcional) ID da campanha |
| link direto | (opcional) Objeto que contém links da loja de aplicativos. Ao usar isso, é importante definir a segmentação por dispositivo também. |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/url/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "url": "https:\/\/google.com",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "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 => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "url": "https:\/\/google.com",
	    "personalizado": "google",
	    "password": "mypass",
	    "expiração": "2020-11-11 12:00:00",
	    "tipo": "respingo",
	    "pixels": [
	        1,
	        2,
	        3,
	        4
	    ],
	    "canal": 1,
	    "deeplink": {
	        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
	        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
	    },
	    "alvo geográfico": [
	        {
	            "location": "Canadá",
	            "link": "https:\/\/google.ca"
	        },
	        {
	            "location": "Estados Unidos",
	            "link": "https:\/\/google.us"
	        }
	    ],
	    "Destido dispositivo": [
	        {
	            "device": "iPhone",
	            "link": "https:\/\/google.com"
	        },
	        {
	            "dispositivo": "Android",
	            "link": "https:\/\/google.com"
	        }
	    ],
	    "parâmetros": [
	        {
	            "nome": "aff",
	            "valor": "3"
	        },
	        {
	            "dispositivo": "gtm_source",
	            "link": "api"
	        }
	    ]
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/url/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "url": "https:\/\/google.com",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/url/:id/update"
carga = {
    "url": "https://google.com",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "maçã": "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"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https://google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https://google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https://google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https://google.com"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/url/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "url": "https:\/\/google.com",
    "personalizado": "google",
    "password": "mypass",
    "expiração": "2020-11-11 12:00:00",
    "tipo": "respingo",
    "pixels": [
        1,
        2,
        3,
        4
    ],
    "canal": 1,
    "deeplink": {
        "apple": "https:\/\/apps.apple.com\/us\/app\/google\/id284815942",
        "google": "https:\/\/play.google.com\/store\/apps\/details?id=com.google.android.googlequicksearchbox&hl=en_CA≷=US"
    },
    "alvo geográfico": [
        {
            "location": "Canadá",
            "link": "https:\/\/google.ca"
        },
        {
            "location": "Estados Unidos",
            "link": "https:\/\/google.us"
        }
    ],
    "Destido dispositivo": [
        {
            "device": "iPhone",
            "link": "https:\/\/google.com"
        },
        {
            "dispositivo": "Android",
            "link": "https:\/\/google.com"
        }
    ],
    "parâmetros": [
        {
            "nome": "aff",
            "valor": "3"
        },
        {
            "dispositivo": "gtm_source",
            "link": "api"
        }
    ]
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Supprimer un lien

EXCLUIR  `https://urlkai.com/api/url/:id/delete`

Pour supprimer un lien, vous devez envoyer une requête DELETE.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/url/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/url/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/url/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/url/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/url/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O link foi excluído com sucesso"
}
```

---

#### Pixels - Open in ChatGPT - Open in Claude

###### Listar pixels

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

Para obter seus códigos de pixels por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/pixels?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixels?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/pixels?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/pixels?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/pixels?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "pixels": [
            {
                "id": 1,
                "tipo": "gtmpixel",
                "name": "Pixel GTM",
                "tag": "GA-123456789",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "tipo": "twitterpixel",
                "name": "Pixel do Twitter",
                "tag": "1234567",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

###### Criar um pixel

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

Um pixel pode ser criado usando esse ponto de extremidade. Você precisa enviar o tipo de pixel e a tag.

| **Paramètre** | **La descrição** |
| --- | --- |
| tipo | (obrigatório) gtmpixel | gapixel | fbpixel | AdwordsPixel | linkedinpixel | twitterpixel | AdrollPixel | Quorapixel | Pinterest | bing | Snapchat | Reddit | Tiktok |
| nome | (obrigatório) Nome personalizado para o pixel |
| etiqueta | (obrigatório) A tag para o pixel |

cURL
PHP
Node.js
Python
C#

```
curl --location --request POST 'https://urlkai.com/api/pixel/add' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "tipo": "gtmpixel",
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/add",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "tipo": "gtmpixel",
	    "name": "Meu GTM",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'POST',
    'url': 'https://urlkai.com/api/pixel/add',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "tipo": "gtmpixel",
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/pixel/add"
carga = {
    "tipo": "gtmpixel",
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("POST", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://urlkai.com/api/pixel/add");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "tipo": "gtmpixel",
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

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

###### Mettre à jour le pixel

PÔR  `https://urlkai.com/api/pixel/:id/update`

Para atualizar um pixel, você precisa enviar dados válidos em JSON por meio de uma solicitação PUT. Os dados devem ser enviados como o corpo bruto de sua solicitação, conforme mostrado abaixo. O exemplo abaixo mostra todos os parâmetros que você pode enviar, mas não é obrigado a enviar todos (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| nome | (opcional) Nome personalizado para o pixel |
| etiqueta | (obrigatório) A tag para o pixel |

cURL
PHP
Node.js
Python
C#

```
curl --location --request PUT 'https://urlkai.com/api/pixel/:id/update' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
--data-raw '{
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}'
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/update",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "COLOCAR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    CURLOPT_POSTFIELDS => 
        '{
	    "name": "Meu GTM",
	    "tag": "GTM-ABCDE"
	}',
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'PUT',
    'url': 'https://urlkai.com/api/pixel/:id/update',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    corpo: JSON.stringify({
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}),
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/pixel/:id/update"
carga = {
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("PUT", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var solicitação = new HttpRequestMessage(HttpMethod.Put, "https://urlkai.com/api/pixel/:id/update");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{
    "name": "Meu GTM",
    "tag": "GTM-ABCDE"
}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O pixel foi atualizado com sucesso."
}
```

###### Excluir pixel

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

Para excluir um pixel, você precisa enviar uma solicitação DELETE.

cURL
PHP
Node.js
Python
C#

```
curl --location --request DELETE 'https://urlkai.com/api/pixel/:id/delete' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/pixel/:id/delete",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "EXCLUIR",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'DELETE',
    'url': 'https://urlkai.com/api/pixel/:id/delete',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/pixel/:id/delete"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("DELETE", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://urlkai.com/api/pixel/:id/delete");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": 0,
    "message": "O pixel foi excluído com sucesso."
}
```

---

#### Splash personnalisé - Open in ChatGPT - Open in Claude

###### Listar Splash personalizado

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

Para obter páginas iniciais personalizadas por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/splash?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/splash?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/splash?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/splash?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/splash?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "splash": [
            {
                "id": 1,
                "name": "Promoção do Produto 1",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "name": "Promoção do Produto 2",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```

---

#### Sobreposições CTA - Open in ChatGPT - Open in Claude

###### Listar sobreposições de CTA

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

Para obter sobreposições de cta por meio da API, você pode usar esse endpoint. Você também pode filtrar dados (consulte a tabela para obter mais informações).

| **Paramètre** | **La descrição** |
| --- | --- |
| limite | (opcional) Resultado de dados por página |
| página | (opcional) Solicitação de página atual |

cURL
PHP
Node.js
Python
C#

```
curl --location --request GET 'https://urlkai.com/api/overlay?limit=2&page=1' \
--header 'Autorização: Portador YOURAPIKEY' \
--header 'Tipo de conteúdo: aplicativo / json' \
```

```
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => "https://urlkai.com/api/overlay?limit=2&page=1",
    CURLOPT_RETURNTRANSFER => verdadeiro,
    CURLOPT_MAXREDIRS => 2,
    CURLOPT_TIMEOUT = > 10,
    CURLOPT_FOLLOWLOCATION => verdadeiro,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Autorização: Portador YOURAPIKEY",
        "Tipo de conteúdo: application/json",
    ],
    
));

$response = curl_exec($curl);

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

```
var solicitação = require('solicitação');
var opções = {
    'method': 'GET',
    'url': 'https://urlkai.com/api/overlay?limit=2&page=1',
    'cabeçalhos': {
        'Autorização': 'Portador YOURAPIKEY',
        'Tipo de conteúdo': 'aplicativo / json'
    },
    
};
request(opções, função (erro, resposta) {
    if (error) throw new Error(error);
    console.log(resposta.corpo);
});
```

```
Solicitações de importação
url = "https://urlkai.com/api/overlay?limit=2&page=1"
carga = {}
cabeçalhos = {
    'Autorização': 'Portador YOURAPIKEY',
    'Tipo de conteúdo': 'aplicativo / json'
}
resposta = requests.request("GET", url, cabeçalhos=cabeçalhos, json=payload)
print(resposta.texto)
```

```
var cliente = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://urlkai.com/api/overlay?limit=2&page=1");
pedir. Headers.Add("Autorização", "Portador YOURAPIKEY");
var content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json");
pedir. Conteúdo = conteúdo;
var response = await client. SendAsync(solicitação);
resposta. EnsureSuccessStatusCode();
Console.WriteLine(await response. Content.ReadAsStringAsync());
```

###### Une clé API est requise pour les demandes à traiter par le système. Une fois qu'un utilisateur s'enregistre, une clé API est générée automatiquement pour cet utilisateur. La clé API doit être envoyée avec chaque requête via le paramètre clé (voir l'exemple complet ci-dessous). Si la clé API n'est pas envoyée ou a expiré, une erreur se produit. Assurez-vous de garder votre clé secrète de l'API pour éviter tout abus.

```
{
    "erro": "0",
    "dados": {
        "resultado": 2,
        "perpage": 2,
        "página atual": 1,
        "próxima página": 1,
        "maxpage": 1,
        "cta": [
            {
                "id": 1,
                "tipo": "mensagem",
                "name": "Promoção do Produto 1",
                "data": "2020-11-10 18:00:00"
            },
            {
                "id": 2,
                "tipo": "contato",
                "name": "Página de contato",
                "data": "2020-11-10 18:10:00"
            }
        ]
    }
}
```