Contatos

curl "https://api.atys.pro/api/v1/contacts/custom-fields" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/custom-fields', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/custom-fields',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/custom-fields');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/custom-fields', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/custom-fields", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/tags" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/tags', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/tags',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/tags');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/tags', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/tags", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/company-channels" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/company-channels', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/company-channels',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/company-channels');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/company-channels', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/company-channels", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/origins" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/origins', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/origins',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/origins');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/origins', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/origins", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/sectors" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/sectors', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/sectors',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/sectors');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/sectors', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/sectors", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/users" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/users', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/users',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/users');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/users', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/users", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Maria Cliente",
    "email": "maria@cliente.com.br",
    "channels": [
      {
        "company_channel_id": 44,
        "key": "+55 (11) 98888-7777"
      }
    ],
    "tag_ids": [9],
    "custom_fields": [
      {
        "field_id": 55,
        "value": "529.982.247-25"
      }
    ]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "name": "Maria Cliente",
    "email": "maria@cliente.com.br",
    "channels": [
      {
        "company_channel_id": 44,
        "key": "+55 (11) 98888-7777"
      }
    ],
    "tag_ids": [9],
    "custom_fields": [
      {
        "field_id": 55,
        "value": "529.982.247-25"
      }
    ]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'name': 'Maria Cliente',
        'email': 'maria@cliente.com.br',
        'channels': [
            {
                'company_channel_id': 44,
                'key': '+55 (11) 98888-7777'
            }
        ],
        'tag_ids': [9],
        'custom_fields': [
            {
                'field_id': 55,
                'value': '529.982.247-25'
            }
        ]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Maria Cliente',
        'email' => 'maria@cliente.com.br',
        'channels' => [
            [
                'company_channel_id' => 44,
                'key' => '+55 (11) 98888-7777'
            ]
        ],
        'tag_ids' => [9],
        'custom_fields' => [
            [
                'field_id' => 55,
                'value' => '529.982.247-25'
            ]
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'name' => 'Maria Cliente',
        'email' => 'maria@cliente.com.br',
        'channels' => [
            [
                'company_channel_id' => 44,
                'key' => '+55 (11) 98888-7777'
            ]
        ],
        'tag_ids' => [9],
        'custom_fields' => [
            [
                'field_id' => 55,
                'value' => '529.982.247-25'
            ]
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "name": "Maria Cliente",
      "email": "maria@cliente.com.br",
      "channels": [
        {
          "company_channel_id": 44,
          "key": "+55 (11) 98888-7777"
        }
      ],
      "tag_ids": [9],
      "custom_fields": [
        {
          "field_id": 55,
          "value": "529.982.247-25"
        }
      ]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Maria",
    "channels": [
      {
        "company_channel_id": 44,
        "key": "5511988887777"
      }
    ]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "name": "Maria",
    "channels": [
      {
        "company_channel_id": 44,
        "key": "5511988887777"
      }
    ]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'name': 'Maria',
        'channels': [
            {
                'company_channel_id': 44,
                'key': '5511988887777'
            }
        ]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Maria',
        'channels' => [
            [
                'company_channel_id' => 44,
                'key' => '5511988887777'
            ]
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'name' => 'Maria',
        'channels' => [
            [
                'company_channel_id' => 44,
                'key' => '5511988887777'
            ]
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "name": "Maria",
      "channels": [
        {
          "company_channel_id": 44,
          "key": "5511988887777"
        }
      ]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts?q=maria&tag_ids%5B%5D=9&per_page=25" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts?q=maria&tag_ids%5B%5D=9&per_page=25', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts?q=maria&tag_ids%5B%5D=9&per_page=25',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts?q=maria&tag_ids%5B%5D=9&per_page=25');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'query' => [
        'q' => 'maria',
        'tag_ids[]' => 9,
        'per_page' => 25
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts?q=maria&tag_ids%5B%5D=9&per_page=25", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/lookup?phone=11988887777" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/lookup?phone=11988887777', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/lookup?phone=11988887777',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/lookup?phone=11988887777');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/lookup', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'query' => [
        'phone' => '11988887777'
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/lookup?phone=11988887777", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/5120" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/5120',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/5120', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/5120", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X PATCH "https://api.atys.pro/api/v1/contacts/5120" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Maria Silva",
    "description": "Cliente desde 2024"
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120', {
  method: 'PATCH',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "name": "Maria Silva",
    "description": "Cliente desde 2024"
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.patch(
    'https://api.atys.pro/api/v1/contacts/5120',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'name': 'Maria Silva',
        'description': 'Cliente desde 2024'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Maria Silva',
        'description' => 'Cliente desde 2024'
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('PATCH', 'v1/contacts/5120', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'name' => 'Maria Silva',
        'description' => 'Cliente desde 2024'
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "name": "Maria Silva",
      "description": "Cliente desde 2024"
    }`)

    req, _ := http.NewRequest("PATCH", "https://api.atys.pro/api/v1/contacts/5120", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/5120/channels" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/5120/channels',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/5120/channels', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/5120/channels", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/5120/channels/77120" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77120', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77120',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77120');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/5120/channels/77120', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/5120/channels/77120", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/5120/channels" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "company_channel_id": 45,
    "key": "5521977776666",
    "name": "Maria (WhatsApp)",
    "user_id": 81,
    "sector_id": 6
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "company_channel_id": 45,
    "key": "5521977776666",
    "name": "Maria (WhatsApp)",
    "user_id": 81,
    "sector_id": 6
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/5120/channels',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'company_channel_id': 45,
        'key': '5521977776666',
        'name': 'Maria (WhatsApp)',
        'user_id': 81,
        'sector_id': 6
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'company_channel_id' => 45,
        'key' => '5521977776666',
        'name' => 'Maria (WhatsApp)',
        'user_id' => 81,
        'sector_id' => 6
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/5120/channels', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'company_channel_id' => 45,
        'key' => '5521977776666',
        'name' => 'Maria (WhatsApp)',
        'user_id' => 81,
        'sector_id' => 6
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "company_channel_id": 45,
      "key": "5521977776666",
      "name": "Maria (WhatsApp)",
      "user_id": 81,
      "sector_id": 6
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/5120/channels", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X PATCH "https://api.atys.pro/api/v1/contacts/5120/channels/77131" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Maria WhatsApp",
    "user_id": null
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77131', {
  method: 'PATCH',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "name": "Maria WhatsApp",
    "user_id": null
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.patch(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77131',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'name': 'Maria WhatsApp',
        'user_id': None
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77131');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Maria WhatsApp',
        'user_id' => null
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('PATCH', 'v1/contacts/5120/channels/77131', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'name' => 'Maria WhatsApp',
        'user_id' => null
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "name": "Maria WhatsApp",
      "user_id": null
    }`)

    req, _ := http.NewRequest("PATCH", "https://api.atys.pro/api/v1/contacts/5120/channels/77131", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/5120/custom-fields" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/custom-fields', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/5120/custom-fields',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/custom-fields');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/5120/custom-fields', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/5120/custom-fields", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X PUT "https://api.atys.pro/api/v1/contacts/5120/custom-fields" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "fields": [
      {
        "field_id": 56,
        "value": "Loja Centro"
      },
      {
        "field_id": 57,
        "value": null
      }
    ]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/custom-fields', {
  method: 'PUT',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "fields": [
      {
        "field_id": 56,
        "value": "Loja Centro"
      },
      {
        "field_id": 57,
        "value": null
      }
    ]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.put(
    'https://api.atys.pro/api/v1/contacts/5120/custom-fields',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'fields': [
            {
                'field_id': 56,
                'value': 'Loja Centro'
            },
            {
                'field_id': 57,
                'value': None
            }
        ]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/custom-fields');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'fields' => [
            [
                'field_id' => 56,
                'value' => 'Loja Centro'
            ],
            [
                'field_id' => 57,
                'value' => null
            ]
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('PUT', 'v1/contacts/5120/custom-fields', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'fields' => [
            [
                'field_id' => 56,
                'value' => 'Loja Centro'
            ],
            [
                'field_id' => 57,
                'value' => null
            ]
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "fields": [
        {
          "field_id": 56,
          "value": "Loja Centro"
        },
        {
          "field_id": 57,
          "value": null
        }
      ]
    }`)

    req, _ := http.NewRequest("PUT", "https://api.atys.pro/api/v1/contacts/5120/custom-fields", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/5120/channels/77120/custom-fields', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X PUT "https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "fields": [
      {
        "field_id": 55,
        "value": "529.982.247-25"
      }
    ]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields', {
  method: 'PUT',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "fields": [
      {
        "field_id": 55,
        "value": "529.982.247-25"
      }
    ]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.put(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'fields': [
            {
                'field_id': 55,
                'value': '529.982.247-25'
            }
        ]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'fields' => [
            [
                'field_id' => 55,
                'value' => '529.982.247-25'
            ]
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('PUT', 'v1/contacts/5120/channels/77120/custom-fields', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'fields' => [
            [
                'field_id' => 55,
                'value' => '529.982.247-25'
            ]
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "fields": [
        {
          "field_id": 55,
          "value": "529.982.247-25"
        }
      ]
    }`)

    req, _ := http.NewRequest("PUT", "https://api.atys.pro/api/v1/contacts/5120/channels/77120/custom-fields", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X PUT "https://api.atys.pro/api/v1/contacts/5120/channels/77120/tags" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "tag_ids": [9]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77120/tags', {
  method: 'PUT',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "tag_ids": [9]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.put(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77120/tags',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'tag_ids': [9]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77120/tags');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'tag_ids' => [9]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('PUT', 'v1/contacts/5120/channels/77120/tags', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'tag_ids' => [9]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "tag_ids": [9]
    }`)

    req, _ := http.NewRequest("PUT", "https://api.atys.pro/api/v1/contacts/5120/channels/77120/tags", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X DELETE "https://api.atys.pro/api/v1/contacts/5120/channels/77131" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120/channels/77131', {
  method: 'DELETE',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

console.log(response.status); // 204 = excluído

import os
import requests

response = requests.delete(
    'https://api.atys.pro/api/v1/contacts/5120/channels/77131',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
print(response.status_code)  # 204 = excluído

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120/channels/77131');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('DELETE', 'v1/contacts/5120/channels/77131', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("DELETE", "https://api.atys.pro/api/v1/contacts/5120/channels/77131", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X DELETE "https://api.atys.pro/api/v1/contacts/5120" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/5120', {
  method: 'DELETE',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

console.log(response.status); // 204 = excluído

import os
import requests

response = requests.delete(
    'https://api.atys.pro/api/v1/contacts/5120',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
print(response.status_code)  # 204 = excluído

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/5120');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('DELETE', 'v1/contacts/5120', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("DELETE", "https://api.atys.pro/api/v1/contacts/5120", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/bulk/trf_6543a1b2c3d4e5.12345678", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/close-reasons?company_channel_id=44" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/close-reasons?company_channel_id=44', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/close-reasons?company_channel_id=44',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/close-reasons?company_channel_id=44');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/close-reasons', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'query' => [
        'company_channel_id' => 44
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/close-reasons?company_channel_id=44", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/close-reasons" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "company_channel_id": 44,
    "text": "Venda concluída"
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/close-reasons', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "company_channel_id": 44,
    "text": "Venda concluída"
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/close-reasons',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'company_channel_id': 44,
        'text': 'Venda concluída'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/close-reasons');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'company_channel_id' => 44,
        'text' => 'Venda concluída'
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/close-reasons', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'company_channel_id' => 44,
        'text' => 'Venda concluída'
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "company_channel_id": 44,
      "text": "Venda concluída"
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/close-reasons", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/assign" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "contact_channel_ids": [9120, 9121, 9122],
    "user_id": 77,
    "sector_id": 12
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/assign', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "contact_channel_ids": [9120, 9121, 9122],
    "user_id": 77,
    "sector_id": 12
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/assign',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'contact_channel_ids': [9120, 9121, 9122],
        'user_id': 77,
        'sector_id': 12
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/assign');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'contact_channel_ids' => [9120, 9121, 9122],
        'user_id' => 77,
        'sector_id' => 12
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/assign', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'contact_channel_ids' => [9120, 9121, 9122],
        'user_id' => 77,
        'sector_id' => 12
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "contact_channel_ids": [9120, 9121, 9122],
      "user_id": 77,
      "sector_id": 12
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/assign", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/transfer" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "contact_channel_ids": [9120, 9121, 9122],
    "target_company_channel_id": 51,
    "transfer_messages": true,
    "confirm_merge": false
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/transfer', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "contact_channel_ids": [9120, 9121, 9122],
    "target_company_channel_id": 51,
    "transfer_messages": true,
    "confirm_merge": false
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/transfer',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'contact_channel_ids': [9120, 9121, 9122],
        'target_company_channel_id': 51,
        'transfer_messages': True,
        'confirm_merge': False
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/transfer');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'contact_channel_ids' => [9120, 9121, 9122],
        'target_company_channel_id' => 51,
        'transfer_messages' => true,
        'confirm_merge' => false
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/transfer', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'contact_channel_ids' => [9120, 9121, 9122],
        'target_company_channel_id' => 51,
        'transfer_messages' => true,
        'confirm_merge' => false
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "contact_channel_ids": [9120, 9121, 9122],
      "target_company_channel_id": 51,
      "transfer_messages": true,
      "confirm_merge": false
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/transfer", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/transfer" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "without_user": true
    },
    "target_company_channel_id": 51
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/transfer', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "without_user": true
    },
    "target_company_channel_id": 51
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/transfer',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'scope': 'filtered',
        'filters': {
            'company_channel_id': 44,
            'without_user': True
        },
        'target_company_channel_id': 51
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/transfer');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'without_user' => true
        ],
        'target_company_channel_id' => 51
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/transfer', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'without_user' => true
        ],
        'target_company_channel_id' => 51
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "scope": "filtered",
      "filters": {
        "company_channel_id": 44,
        "without_user": true
      },
      "target_company_channel_id": 51
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/transfer", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/tags" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "add",
    "tag_ids": [310, 311],
    "contact_channel_ids": [9120, 9121, 9122]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/tags', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "action": "add",
    "tag_ids": [310, 311],
    "contact_channel_ids": [9120, 9121, 9122]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/tags',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'action': 'add',
        'tag_ids': [310, 311],
        'contact_channel_ids': [9120, 9121, 9122]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/tags');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'action' => 'add',
        'tag_ids' => [310, 311],
        'contact_channel_ids' => [9120, 9121, 9122]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/tags', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'action' => 'add',
        'tag_ids' => [310, 311],
        'contact_channel_ids' => [9120, 9121, 9122]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "action": "add",
      "tag_ids": [310, 311],
      "contact_channel_ids": [9120, 9121, 9122]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/tags", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/tags" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "remove",
    "tag_ids": [310],
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "tag_ids": [310],
      "created_from": "2026-10-01",
      "created_to": "2026-10-31"
    }
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/tags', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "action": "remove",
    "tag_ids": [310],
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "tag_ids": [310],
      "created_from": "2026-10-01",
      "created_to": "2026-10-31"
    }
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/tags',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'action': 'remove',
        'tag_ids': [310],
        'scope': 'filtered',
        'filters': {
            'company_channel_id': 44,
            'tag_ids': [310],
            'created_from': '2026-10-01',
            'created_to': '2026-10-31'
        }
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/tags');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'action' => 'remove',
        'tag_ids' => [310],
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'tag_ids' => [310],
            'created_from' => '2026-10-01',
            'created_to' => '2026-10-31'
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/tags', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'action' => 'remove',
        'tag_ids' => [310],
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'tag_ids' => [310],
            'created_from' => '2026-10-01',
            'created_to' => '2026-10-31'
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "action": "remove",
      "tag_ids": [310],
      "scope": "filtered",
      "filters": {
        "company_channel_id": 44,
        "tag_ids": [310],
        "created_from": "2026-10-01",
        "created_to": "2026-10-31"
      }
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/tags", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/bulk/close/survey-preview?company_channel_id=44&close_reason_id=812" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/close/survey-preview?company_channel_id=44&close_reason_id=812', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/bulk/close/survey-preview?company_channel_id=44&close_reason_id=812',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/close/survey-preview?company_channel_id=44&close_reason_id=812');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/bulk/close/survey-preview', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'query' => [
        'company_channel_id' => 44,
        'close_reason_id' => 812
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/bulk/close/survey-preview?company_channel_id=44&close_reason_id=812", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/close" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "company_channel_id": 44,
    "close_reason_id": 812,
    "contact_channel_ids": [9120, 9121, 9122]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/close', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "company_channel_id": 44,
    "close_reason_id": 812,
    "contact_channel_ids": [9120, 9121, 9122]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/close',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'company_channel_id': 44,
        'close_reason_id': 812,
        'contact_channel_ids': [9120, 9121, 9122]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/close');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'company_channel_id' => 44,
        'close_reason_id' => 812,
        'contact_channel_ids' => [9120, 9121, 9122]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/close', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'company_channel_id' => 44,
        'close_reason_id' => 812,
        'contact_channel_ids' => [9120, 9121, 9122]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "company_channel_id": 44,
      "close_reason_id": 812,
      "contact_channel_ids": [9120, 9121, 9122]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/close", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/close" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "company_channel_id": 44,
    "close_reason_id": 812,
    "send_satisfaction_survey": true
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/close', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "company_channel_id": 44,
    "close_reason_id": 812,
    "send_satisfaction_survey": true
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/close',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'company_channel_id': 44,
        'close_reason_id': 812,
        'send_satisfaction_survey': True
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/close');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'company_channel_id' => 44,
        'close_reason_id' => 812,
        'send_satisfaction_survey' => true
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/close', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'company_channel_id' => 44,
        'close_reason_id' => 812,
        'send_satisfaction_survey' => true
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "company_channel_id": 44,
      "close_reason_id": 812,
      "send_satisfaction_survey": true
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/close", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/bulk/delete" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "contact_channel_ids": [9120, 9121, 9122]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/bulk/delete', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "contact_channel_ids": [9120, 9121, 9122]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/bulk/delete',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'contact_channel_ids': [9120, 9121, 9122]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/bulk/delete');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'contact_channel_ids' => [9120, 9121, 9122]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/bulk/delete', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'contact_channel_ids' => [9120, 9121, 9122]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "contact_channel_ids": [9120, 9121, 9122]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/bulk/delete", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/import" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "company_channel_id": 44,
    "number_type": "national",
    "contacts": [
      {
        "name": "Maria Cliente",
        "phone": "(11) 98888-0001",
        "email": "maria@cliente.com.br"
      },
      {
        "name": "João Comprador",
        "phone": "11988880002"
      }
    ]
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/import', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "company_channel_id": 44,
    "number_type": "national",
    "contacts": [
      {
        "name": "Maria Cliente",
        "phone": "(11) 98888-0001",
        "email": "maria@cliente.com.br"
      },
      {
        "name": "João Comprador",
        "phone": "11988880002"
      }
    ]
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/import',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'company_channel_id': 44,
        'number_type': 'national',
        'contacts': [
            {
                'name': 'Maria Cliente',
                'phone': '(11) 98888-0001',
                'email': 'maria@cliente.com.br'
            },
            {
                'name': 'João Comprador',
                'phone': '11988880002'
            }
        ]
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/import');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'company_channel_id' => 44,
        'number_type' => 'national',
        'contacts' => [
            [
                'name' => 'Maria Cliente',
                'phone' => '(11) 98888-0001',
                'email' => 'maria@cliente.com.br'
            ],
            [
                'name' => 'João Comprador',
                'phone' => '11988880002'
            ]
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/import', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'company_channel_id' => 44,
        'number_type' => 'national',
        'contacts' => [
            [
                'name' => 'Maria Cliente',
                'phone' => '(11) 98888-0001',
                'email' => 'maria@cliente.com.br'
            ],
            [
                'name' => 'João Comprador',
                'phone' => '11988880002'
            ]
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "company_channel_id": 44,
      "number_type": "national",
      "contacts": [
        {
          "name": "Maria Cliente",
          "phone": "(11) 98888-0001",
          "email": "maria@cliente.com.br"
        },
        {
          "name": "João Comprador",
          "phone": "11988880002"
        }
      ]
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/import", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/import/import_6543a1b2c3d4f0.87654321" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/import/import_6543a1b2c3d4f0.87654321', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/import/import_6543a1b2c3d4f0.87654321',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/import/import_6543a1b2c3d4f0.87654321');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/import/import_6543a1b2c3d4f0.87654321', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/import/import_6543a1b2c3d4f0.87654321", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl -X POST "https://api.atys.pro/api/v1/contacts/export" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "fields": ["name", "email", "phone", "attendant", "tags"],
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "tag_ids": [310],
      "created_from": "2026-10-01",
      "created_to": "2026-10-31"
    }
  }'

const response = await fetch('https://api.atys.pro/api/v1/contacts/export', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "fields": ["name", "email", "phone", "attendant", "tags"],
    "scope": "filtered",
    "filters": {
      "company_channel_id": 44,
      "tag_ids": [310],
      "created_from": "2026-10-01",
      "created_to": "2026-10-31"
    }
  })
});

const { data, error } = await response.json();

import os
import requests

response = requests.post(
    'https://api.atys.pro/api/v1/contacts/export',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    },
    json={
        'fields': ['name', 'email', 'phone', 'attendant', 'tags'],
        'scope': 'filtered',
        'filters': {
            'company_channel_id': 44,
            'tag_ids': [310],
            'created_from': '2026-10-01',
            'created_to': '2026-10-31'
        }
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/export');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'fields' => ['name', 'email', 'phone', 'attendant', 'tags'],
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'tag_ids' => [310],
            'created_from' => '2026-10-01',
            'created_to' => '2026-10-31'
        ]
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('POST', 'v1/contacts/export', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
    'json' => [
        'fields' => ['name', 'email', 'phone', 'attendant', 'tags'],
        'scope' => 'filtered',
        'filters' => [
            'company_channel_id' => 44,
            'tag_ids' => [310],
            'created_from' => '2026-10-01',
            'created_to' => '2026-10-31'
        ]
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "bytes"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{
      "fields": ["name", "email", "phone", "attendant", "tags"],
      "scope": "filtered",
      "filters": {
        "company_channel_id": 44,
        "tag_ids": [310],
        "created_from": "2026-10-01",
        "created_to": "2026-10-31"
      }
    }`)

    req, _ := http.NewRequest("POST", "https://api.atys.pro/api/v1/contacts/export", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/export/export_6543a1b2c3d4f9.11223344" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/export/export_6543a1b2c3d4f9.11223344', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/export/export_6543a1b2c3d4f9.11223344',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/export/export_6543a1b2c3d4f9.11223344');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/export/export_6543a1b2c3d4f9.11223344', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/export/export_6543a1b2c3d4f9.11223344", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

curl "https://api.atys.pro/api/v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download" \
  -H "Authorization: Bearer atys_live_SUA_CHAVE" \
  -H "Accept: application/json"

const response = await fetch('https://api.atys.pro/api/v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
    'Accept': 'application/json'
  }
});

const { data, error } = await response.json();

import os
import requests

response = requests.get(
    'https://api.atys.pro/api/v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download',
    headers={
        'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
        'Accept': 'application/json'
    }
)
result = response.json()

<?php

$ch = curl_init('https://api.atys.pro/api/v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer '.getenv('ATYS_API_KEY'),
        'Accept: application/json',
    ],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

<?php

$client = new GuzzleHttp\Client(['base_uri' => 'https://api.atys.pro/api/']);

$response = $client->request('GET', 'v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download', [
    'headers' => [
        'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
        'Accept' => 'application/json',
    ],
]);
$result = json_decode($response->getBody(), true);

package main

import (
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/contacts/export/3f6c2a9e-8d41-4b7a-9c55-1e2f3a4b5c6d/download", nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
    req.Header.Set("Accept", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}