NAV
bash javascript php python

Sobre a API

Api do Integrador DFE disponibiliza algumas de suas funções básicas para uso dos desenvolvedores que desejam utilizar os arquivos fornecidos pela empresa em seus projetos.

Token de Acesso

Para utilizar as requisições abaixo é necessário um Token de Acesso, onde o mesmo é fornecido pelo usuário empresa a qual você deseja fazer as requisições.

Caso não possua um Token de Acesso, entre em contato com o cliente que utiliza o Integrador DFE para a geração do mesmo no painel de administração da empresa.

Arquivos

Tipos

Tipos de arquivos presentes no sistema.

Examplo de Requisição:

curl -X GET \
    -G "http://192.168.88.181:8000/api/file/type" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/file/type"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "GET",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://192.168.88.181:8000/api/file/type',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/file/type'
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('GET', url, headers=headers)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Tipos de arquivo listados com sucesso",
    "data": [
        {
            "id": 9,
            "name": "Atualização pós evento das Notas Fiscais",
            "tag": "nfe-updated",
            "category_name": "Notas",
            "category_tag": "nfe",
            "type_nickname": "Atualizações"
        }
    ]
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

GET api/file/type

Agendamentos

Agendamentos de download de relatórios ou de arquivos.

Examplo de Requisição:

curl -X GET \
    -G "http://192.168.88.181:8000/api/scheduling" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/scheduling"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "GET",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://192.168.88.181:8000/api/scheduling',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/scheduling'
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('GET', url, headers=headers)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Agendamentos listados com sucesso",
    "data": [
        {
            "id": 4,
            "user_id": 1,
            "description": "Geração de relátorio de arquivos com 1 arquivo(s)",
            "finished": 1,
            "progress": 100,
            "link": "Link para download do arquivo"
        }
    ]
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

GET api/scheduling

Máquinas

Lista de máquinas responsáveis pelo envio dos arquivos.

Examplo de Requisição:

curl -X GET \
    -G "http://192.168.88.181:8000/api/empresa-teste/machine" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/machine"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "GET",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://192.168.88.181:8000/api/empresa-teste/machine',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/machine'
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('GET', url, headers=headers)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Máquinas listadas com sucesso",
    "data": [
        {
            "id": 2,
            "user_id": 2,
            "secret": "D592-BC2E-F32A-DD57-E4F2-87B1-65B9-04C5",
            "active": 1
        }
    ]
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

GET api/{slug}/machine

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa escolhida.

Envio de Arquivos

Envio dos arquivos para o sistema, recomenda-se enviar de 50 em 50 arquivos por vez.

Nomenclatura obrigatória dos arquivos

Data e hora da Emissão Nome do arquivo original Tipo do arquivo Formato
20220902083000 AD23201107032123123326592300674950175542872817 .mfe .xml

Examplo de Requisição:

curl -X POST \
    "http://192.168.88.181:8000/api/empresa-teste/D592-BC2E-F32A-DD57-E4F2-87B1-65B9-04C5/file" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}" \
    -d '{"files":[]}'

const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/D592-BC2E-F32A-DD57-E4F2-87B1-65B9-04C5/file"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

let body = {
    "files": []
}

fetch(url, {
    method: "POST",
    headers: headers,
    body: body
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://192.168.88.181:8000/api/empresa-teste/D592-BC2E-F32A-DD57-E4F2-87B1-65B9-04C5/file',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
        'json' => [
            'files' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/D592-BC2E-F32A-DD57-E4F2-87B1-65B9-04C5/file'
payload = {
    "files": []
}
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Mensagem de sucesso"
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

POST api/{slug}/{machine}/file

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa.
machine requerido O segredo da máquina responsável pela emissão do arquivo.

Parâmetros Body

Parâmetro Tipo Status Descrição
files array requerido Lista contendo os arquivos com suas respectivas nomenclaturas.

Lista de Arquivos

Lista dos arquivos por período do documento específico.

Tipos de Recebedores

Examplo de Requisição:

curl -X GET \
    -G "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file?init=2022-01-01&final=2022-01-31&name=AD23201107032123123326592300674950175542872817&types=nfe-output%2Cnfe-input&latest=10" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file"
);

let params = {
    "init": "2022-01-01",
    "final": "2022-01-31",
    "name": "AD23201107032123123326592300674950175542872817",
    "types": "nfe-output,nfe-input",
    "latest": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "GET",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
        'query' => [
            'init'=> '2022-01-01',
            'final'=> '2022-01-31',
            'name'=> 'AD23201107032123123326592300674950175542872817',
            'types'=> 'nfe-output,nfe-input',
            'latest'=> '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file'
params = {
  'init': '2022-01-01',
  'final': '2022-01-31',
  'name': 'AD23201107032123123326592300674950175542872817',
  'types': 'nfe-output,nfe-input',
  'latest': '10',
}
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('GET', url, headers=headers, params=params)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Arquivos listados com sucesso",
    "data": [
        {
            "id": 20,
            "user_id": 2,
            "file_type_id": 1,
            "document": "00000000000000",
            "name": "AD23201107032123123326592300674950175542872817",
            "path": "Path do arquivo no Google Cloud",
            "emited_at": " 13\/11\/2020 08:20:36",
            "created_at": " 23\/12\/2020 17:48:04",
            "type": {
                "id": 1,
                "name": "Cupons Fiscais",
                "tag": "mfe",
                "category_name": "Cupons",
                "category_tag": "mfe",
                "type_nickname": "Cupons"
            },
            "information": {
                "file_id": 20,
                "receiver_type": 2
            }
        }
    ]
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

GET api/{slug}/{document}/file

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa.
document requerido O documento da matriz ou filial presente nos arquivos.

Parâmetros Query

Parâmetro Status Descrição
init requerido O período inicial de emissão do arquivo.
final requerido O período final de emissão do arquivo.
name opcional O nome do arquivo.
types opcional As tags dos tipos de arquivos separadas por vírgula.
latest opcional Buscar os últimos arquivos enviados de acordo com a quantidade escolhida.

Download de Arquivos

Baixar arquivos presentes no sistema.

Observação

Caso apenas um arquivo seja solicitado para download, o sistema retornará um callback com o link para download, do contrário o download será agendado para ser baixado após um período de tempo dependendo da quantidade de arquivos.

Examplo de Requisição:

curl -X POST \
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/download" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}" \
    -d '{"files":[]}'

const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/download"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

let body = {
    "files": []
}

fetch(url, {
    method: "POST",
    headers: headers,
    body: body
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/download',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
        'json' => [
            'files' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/download'
payload = {
    "files": []
}
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Mensagem de sucesso",
    "callback": "Link temporario para download do arquivo."
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

POST api/{slug}/{document}/file/download

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa.
document requerido O documento da matriz ou filial presente nos arquivos.

Parâmetros Body

Parâmetro Tipo Status Descrição
files array requerido Lista contendo os arquivos do sistema.

Geração de Documentos

O sistema retornará um callback com o link para download da DANFE, DANFCE ou DAMDFE

Examplo de Requisição:

curl -X POST \
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/1/document" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/1/document"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "POST",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/1/document',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/1/document'
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('POST', url, headers=headers)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Mensagem de sucesso",
    "callback": "Link temporario para download do arquivo."
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

POST api/{slug}/{document}/file/{file}/document

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa.
document requerido O documento da matriz ou filial presente nos arquivos.
file requerido Id do arquivo no sistema.

Relatório de Arquivos

Agendar relatório por período para download.

Tipos de Arquivo

Tipos de Relatório

Examplo de Requisição:

curl -X POST \
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/report" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}" \
    -d '{"init":"2022-01-01","final":"2022-01-31","reportType":"normal","type":"mfe","clientDocument":"00000000000","cfopReference":false}'

const url = new URL(
    "http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/report"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

let body = {
    "init": "2022-01-01",
    "final": "2022-01-31",
    "reportType": "normal",
    "type": "mfe",
    "clientDocument": "00000000000",
    "cfopReference": false
}

fetch(url, {
    method: "POST",
    headers: headers,
    body: body
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/report',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
        'json' => [
            'init' => '2022-01-01',
            'final' => '2022-01-31',
            'reportType' => 'normal',
            'type' => 'mfe',
            'clientDocument' => '00000000000',
            'cfopReference' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/empresa-teste/00000000000000/file/report'
payload = {
    "init": "2022-01-01",
    "final": "2022-01-31",
    "reportType": "normal",
    "type": "mfe",
    "clientDocument": "00000000000",
    "cfopReference": false
}
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Mensagem de sucesso"
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

POST api/{slug}/{document}/file/report

Parâmetros URL

Parâmetro Status Descrição
slug requerido O slug da empresa.
document requerido O documento da matriz ou filial presente nos arquivos.

Parâmetros Body

Parâmetro Tipo Status Descrição
init string requerido O período inicial de emissão do arquivo.
final string requerido O período final de emissão do arquivo.
reportType string requerido Tipo do relatório a ser gerado.
type string opcional Tipo de arquivo presente no relatório.
clientDocument string opcional Gerar relátorio de arquivos filtrando pelo documento do cliente.
cfopReference boolean opcional Gerar relátorio de arquivos usando CFOP de referência (5929), apenas para relatório Monofásico Alíquota Zero.

Usuário

Empresas

Empresas vinculadas ao usuário autenticado.

Examplo de Requisição:

curl -X GET \
    -G "http://192.168.88.181:8000/api/business" \
    -H "Content-Type: application/json" \
    -H "Request-Type: api/external" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer {access_token}"
const url = new URL(
    "http://192.168.88.181:8000/api/business"
);

let headers = {
    "Content-Type": "application/json",
    "Request-Type": "api/external",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
};

fetch(url, {
    method: "GET",
    headers: headers,
})
    .then(response => response.json())
    .then(json => console.log(json));

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://192.168.88.181:8000/api/business',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Request-Type' => 'api/external',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://192.168.88.181:8000/api/business'
headers = {
  'Content-Type': 'application/json',
  'Request-Type': 'api/external',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}'
}
response = requests.request('GET', url, headers=headers)
response.json()

Examplo de resposta (200):

{
    "success": true,
    "message": "Empresas listadas com sucesso",
    "data": [
        {
            "type": "Matriz",
            "name": "Empresa Teste",
            "document": "00000000000000",
            "slug": {
                "id": 1,
                "user_id": 2,
                "name": "empresa-teste"
            }
        }
    ]
}

Examplo de resposta (403):

{
    "success": false,
    "oneOf": [
        {
            "type": "string",
            "message": "Mensagem de erro"
        },
        {
            "type": "array",
            "message": [
                "Mensagem de erro 1",
                "Mensagem de erro 2",
                "..."
            ]
        }
    ]
}

Examplo de resposta (401):

{
    "message": "Mensagem de erro"
}

Examplo de resposta (500):

{
    "message": "Mensagem de erro"
}

Requisição HTTP

GET api/business

bash javascript php python