--- title: "Primeiros passos para integração - Rest PKI Core" description: "Primeiros passos para integrar ao Rest PKI Core: obtenha o endpoint e a chave de API, configure a biblioteca cliente e faça a primeira chamada." canonical: "https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started" locale: "pt-BR" product: "Rest PKI Core" last_updated: "2026-10-12" --- # Primeiros passos para integração - Rest PKI Core Este artigo leva você do zero até uma primeira chamada bem-sucedida ao [Rest PKI Core](https://docs.lacunasoftware.com/articles/rest-pki/core). Você vai: 1. [Obter as credenciais](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#parameters): o endpoint da instância e uma chave de API 1. [Configurar a biblioteca cliente](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#calling-the-api) da sua linguagem de programação ou chamar a API REST diretamente 1. [Fazer uma primeira chamada](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#first-call) para verificar se está tudo pronto ## Como a integração funciona A sua aplicação se comunica com o Rest PKI Core por uma API REST, autenticada por uma chave de API. As chamadas são sempre feitas pelo **backend** da aplicação: a chave de API dá acesso à sua organização e, por isso, nunca deve chegar a um navegador ou a um aplicativo móvel. Quando uma operação depende do usuário, como escolher um certificado e assinar um documento ou tirar uma selfie para uma verificação biométrica, você não precisa construir essas páginas. O backend cria uma **sessão**, o Rest PKI Core retorna uma URL e o usuário é enviado a uma página hospedada pelo Rest PKI Core. Quando termina, o usuário volta à sua aplicação, que obtém os resultados pela API. Veja [sessões de assinatura](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/signature-sessions) e [sessões de biometria](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/bio-sessions). ## Obtenha as credenciais Você precisa de dois parâmetros: Parâmetro | Descrição ----------- | --------- **Endpoint** | Endereço da instância do Rest PKI Core. Na instância SaaS, é `https://core.pki.rest/`. Numa instância própria, é o endereço do dashboard dela, como `https://restpki.suaempresa.com.br/` **Chave de API** | Chave que identifica a aplicação e autentica as chamadas dela. Tem o formato `MyApp\|0f3c…`: um prefixo tirado do nome da aplicação, um `\|` e 64 caracteres hexadecimais Se você usa a instância SaaS e a sua empresa ainda não tem acesso a ela, entre em contato com o nosso [suporte ao desenvolvedor](mailto:suporte@lacunasoftware.com). Se você usa uma [instância on-premises](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises) própria e ainda não tem uma organização com a qual trabalhar, veja [Criação de organização](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises/create-sub). ### Crie uma chave de API As chaves de API pertencem a **aplicações**. Assim que conseguir entrar no dashboard, crie uma aplicação para o seu sistema e uma chave para ela: 1. Entre no dashboard da instância 1. No menu lateral, clique em **Aplicações** e depois em **Adicionar** 1. Em **Nova Aplicação**, preencha um **Nome** para a aplicação. Se for pedida uma **Organização**, escolha aquela em que o seu sistema vai trabalhar 1. Em **Papéis**, marque **Operador** (veja [Escolhendo os papéis](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#roles) abaixo) 1. Clique em **Criar** 1. Na página da aplicação, clique em **Chaves** e depois em **Adicionar** 1. Em **Nova Chave de Aplicação**, preencha uma **Descrição** (por exemplo, o ambiente que vai usar a chave) e escolha uma **Expiração** (veja [Expiração da chave](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#key-expiration) abaixo); depois clique em **Criar** 1. Copie a chave exibida no diálogo **Chave criada** e guarde-a em um local seguro. **Não será possível vê-la novamente**: se você a perder, crie uma nova chave > **Aviso: Mantenha a chave de API em segredo** > > Quem tiver a chave pode agir sobre a sua organização com os papéis da aplicação dela. Guarde-a como guardaria uma senha: num cofre de > segredos como o Azure Key Vault, numa variável de ambiente ou, durante o desenvolvimento, nos segredos do usuário (user secrets) do .NET. > Nunca faça commit dela no controle de versão e nunca a envie a um navegador ou a um aplicativo móvel. #### Escolhendo os papéis Os papéis de uma aplicação definem o que as chaves dela podem fazer. Dê à aplicação apenas os papéis de que ela precisa: Papel | O que permite ----------------- | ------------- **Operador** | As operações de uma integração: criar e usar sessões de assinatura, assinar documentos, inspecionar assinaturas, autenticar usuários com certificados, emitir carimbos de tempo, executar sessões de biometria, adicionar marcas e carimbos aos documentos e consultar transações. **É o papel de que a maioria das integrações precisa** **Monitor** | Consultar transações, sessões de biometria, cadastros em lote e faturas, sem executar nenhuma operação **Gerente** | Tudo o que um Operador faz, além de gerenciar as configurações da organização e os contextos de segurança. Pode ver aplicações e usuários, mas não gerenciá-los **Administrador** | Tudo, inclusive gerenciar aplicações e usuários #### Expiração da chave A **Expiração** de uma chave pode ser **Em 1 ano**, **Em 2 anos** ou **Nunca expira**. Quando uma chave expira, as chamadas feitas com ela passam a falhar com HTTP 401; por isso, se escolher uma chave que expira, planeje a substituição dela: uma aplicação pode ter mais de uma chave, o que permite criar a nova chave e passar o sistema a usá-la antes que a antiga expire. ## Escolha como chamar a API As APIs do Rest PKI Core são REST simples com JSON, mas você não precisa lidar com HTTP diretamente. A Lacuna oferece bibliotecas cliente que encapsulam a API nas convenções de cada linguagem, junto com projetos de exemplo que as usam: Linguagem | Pacote | Código-fonte | Exemplos --------- | ------ | ------------ | -------- .NET | [Lacuna.RestPkiCore.Client](https://www.nuget.org/packages/Lacuna.RestPkiCore.Client/) no NuGet | — | [PkiSuiteSamples/dotnet](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/dotnet) PHP | [lacuna/restpkicore-client](https://packagist.org/packages/lacuna/restpkicore-client) no Packagist | [GitHub](https://github.com/LacunaSoftware/RestPkiNGPhpClient) | [PkiSuiteSamples/php](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/php/plain) Java | [com.lacunasoftware.restpki:restpkicore-client](https://central.sonatype.com/artifact/com.lacunasoftware.restpki/restpkicore-client) no Maven Central | [GitHub](https://github.com/LacunaSoftware/RestPkiNGJavaClient) | [PkiSuiteSamples/java](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/java/springmvc) Node.js | [restpki-core-client](https://www.npmjs.com/package/restpki-core-client) no npm | [GitHub](https://github.com/LacunaSoftware/RestPkiCoreNodeClient) | [PkiSuiteSamples/nodejs](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/nodejs/expressmvc) Vá para a seção da sua linguagem: * [.NET](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#dotnet) * [PHP](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#php) * [Java](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#java) Para qualquer outra linguagem, [chame a API diretamente](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#rest). ### .NET Adicione ao seu projeto o pacote do NuGet [Lacuna.RestPkiCore.Client](https://www.nuget.org/packages/Lacuna.RestPkiCore.Client/): ```bash dotnet add package Lacuna.RestPkiCore.Client ``` O pacote é compilado para o .NET Standard 2.0, então roda no .NET 5 ou posterior, no .NET Core 2.0 ou posterior e no .NET Framework 4.6.1 ou posterior (a Microsoft recomenda a 4.7.2 ou posterior para bibliotecas .NET Standard 2.0). > **Observação** > > O pacote se chama `Lacuna.RestPkiCore.Client`, mas as classes dele ficam no namespace `Lacuna.RestPki.Client`. #### Aplicações ASP.NET Core Registre os serviços do Rest PKI Core no *Program.cs*, vinculando as opções deles à seção de configuração `RestPki`: ```cs builder.Services.AddRestPki().Configure(builder.Configuration.GetSection("RestPki")); ``` Em seguida, adicione a seção ao *appsettings.json*, sem a chave de API: ```json { "RestPki": { "Endpoint": "https://core.pki.rest/" } } ``` Forneça a chave de API por uma fonte que fique fora do controle de versão. Durante o desenvolvimento, use os [segredos do usuário](https://learn.microsoft.com/aspnet/core/security/app-secrets): ```bash dotnet user-secrets set "RestPki:ApiKey" "YOUR_API_KEY" ``` Em produção, defina a variável de ambiente `RestPki__ApiKey` ou use um cofre de segredos como o Azure Key Vault. O ASP.NET Core combina essas fontes na mesma seção `RestPki`. Onde a aplicação precisar chamar o Rest PKI Core, peça um `IRestPkiService` por injeção de dependência: ```cs using Lacuna.RestPki.Client; public class SignatureController : Controller { private readonly IRestPkiService restPkiService; public SignatureController(IRestPkiService restPkiService) { this.restPkiService = restPkiService; } ... } ``` O `AddRestPki()` também registra o `IRestBioService`, o serviço usado nas [sessões de biometria](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/bio-sessions). > **Dica** > > Se preferir definir as opções no código, passe-as ao `AddRestPki()`: > `builder.Services.AddRestPki(options => { options.Endpoint = ...; options.ApiKey = ...; });` #### Outras aplicações .NET Se a aplicação não usa a injeção de dependência do ASP.NET Core, como numa aplicação .NET Framework ou de console, obtenha um `IRestPkiService` da classe estática `RestPkiServiceFactory`: ```cs using Lacuna.RestPki.Client; var restPkiService = RestPkiServiceFactory.GetService(new RestPkiOptions() { Endpoint = ConfigurationManager.AppSettings["RestPkiEndpoint"], ApiKey = ConfigurationManager.AppSettings["RestPkiApiKey"], }); ``` Neste exemplo, os parâmetros vêm da seção `appSettings` do arquivo *web.config* ou *app.config*, mas podem vir de onde você preferir. Para sessões de biometria, use `RestPkiServiceFactory.GetBioService()`, que recebe os mesmos parâmetros. Cada chamada à `RestPkiServiceFactory` cria um novo cliente HTTP; por isso, crie o serviço uma vez e reutilize-o, por exemplo num campo estático, em vez de criar um a cada requisição. #### Opções O `RestPkiOptions` tem as propriedades a seguir, que também podem ser definidas na seção de configuração `RestPki`: Propriedade | Descrição ---------------- | --------- `Endpoint` | Endereço da instância do Rest PKI Core. Se o endereço tiver um caminho, termine-o com uma barra (`https://suaempresa.com.br/restpki/`); caso contrário, o último segmento do caminho é descartado `ApiKey` | A chave de API da aplicação `CultureName` | Cultura das respostas da API, como `en-US`, `pt-BR` ou `es-ES` (veja [Cultura](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#dotnet-culture) abaixo). Também disponível como `Culture`, do tipo `CultureInfo` `TimeoutSeconds` | Quanto tempo esperar por cada resposta, em segundos. Se não for definido, o cliente espera 60 segundos. Também disponível como `Timeout`, do tipo `TimeSpan` #### Cultura O cliente informa ao Rest PKI Core qual cultura usar em cada chamada e, por padrão, usa a cultura da thread atual (`Thread.CurrentThread.CurrentUICulture`). Isso funciona bem quando a aplicação define a cultura de cada requisição, como o ASP.NET Core faz com a localização de requisições (request localization). Para usar sempre a mesma cultura, independentemente da thread, defina `CultureName`. No ASP.NET Core, adicione a propriedade à seção de configuração: ```json { "RestPki": { "Endpoint": "https://core.pki.rest/", "CultureName": "en-US" } } ``` Nos demais casos, defina-a no `RestPkiOptions`: ```cs var restPkiService = RestPkiServiceFactory.GetService(new RestPkiOptions() { ..., CultureName = "en-US", }); ``` #### Erros Os métodos do `IRestPkiService` podem lançar as seguintes exceções: Exceção | Quando --------------------------------- | ------ `RestPkiExceptionV2` | A API rejeitou a requisição (HTTP 422). Compare a propriedade `ErrorCode`, do tipo `ErrorCodesV2`, com os [códigos de erro](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/error-codes). A propriedade `ErrorMessage` descreve o erro em inglês e serve para os seus logs, não para os seus usuários `ValidationException` | Um certificado ou uma assinatura não passou na validação. A propriedade `ValidationResults` indica o que falhou `RestForbiddenOperationException` | A aplicação não tem um papel que permita a operação (HTTP 403, veja [Escolhendo os papéis](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#roles)) `RestErrorException` | Qualquer outro erro HTTP, como 401 por uma chave de API ausente ou inválida. A propriedade `StatusCode` tem o código de status HTTP (veja [Códigos de status HTTP](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#http-status-codes)) `RestUnreachableException` | Não foi possível acessar o endpoint: verifique o endereço do endpoint e a sua rede `TimeoutException` | A resposta demorou mais que `TimeoutSeconds` `RestPkiExceptionV2` e `ValidationException` ficam no namespace `Lacuna.RestPki.Client`, e as demais classes `Rest…Exception`, no namespace `Lacuna.RestClient`. Todas derivam de `Lacuna.RestClient.RestException`; para tratar qualquer erro da API num único lugar, capture `RestException` (e `TimeoutException`, que é uma exceção padrão do .NET). ### PHP Adicione ao seu projeto o pacote do Composer [lacuna/restpkicore-client](https://packagist.org/packages/lacuna/restpkicore-client) (se ainda não tem o Composer, [obtenha-o aqui](https://getcomposer.org/)): ```bash composer require lacuna/restpkicore-client ``` O pacote requer o PHP 5.5 ou posterior e usa o Guzzle 6 ou 7 para fazer as chamadas HTTP. Ele é de código aberto, hospedado no [GitHub](https://github.com/LacunaSoftware/RestPkiNGPhpClient): fique à vontade para fazer um fork se precisar personalizá-lo. Crie um `RestPkiService`, que implementa `RestPkiServiceInterface`, passando a ele um `RestPkiCoreClient` construído com o **endpoint** e a **chave de API**: ```php use Lacuna\RestPki\RestPkiOptions; use Lacuna\RestPki\RestPkiCoreClient; use Lacuna\RestPki\RestPkiService; $options = new RestPkiOptions('https://core.pki.rest/', getenv('RESTPKI_API_KEY')); $client = new RestPkiCoreClient($options); $service = new RestPkiService($client); ``` Neste exemplo, a chave de API vem da variável de ambiente `RESTPKI_API_KEY`, o que a mantém fora do código. #### Cultura Para definir a cultura das respostas da API, passe-a como terceiro parâmetro do `RestPkiOptions`: ```php $options = new RestPkiOptions('https://core.pki.rest/', getenv('RESTPKI_API_KEY'), 'en-US'); ``` #### Erros Todas as exceções a seguir ficam no namespace `Lacuna\RestPki`: Exceção | Quando -------------------------- | ------ `RestPkiException` | A API rejeitou a requisição (HTTP 422). `getErrorCode()` retorna o [código de erro](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/error-codes) e `getDetail()` descreve o erro, para os seus logs `ValidationException` | Um certificado ou uma assinatura não passou na validação `RestErrorException` | Qualquer outro erro HTTP. `getStatusCode()` retorna o código de status HTTP (veja [Códigos de status HTTP](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#http-status-codes)) `RestUnreachableException` | Não foi possível acessar o endpoint #### Exemplos em PHP No nosso [repositório de exemplos](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/php/plain/public), as pastas cujo nome termina em `-rest-core` usam o Rest PKI Core. O endpoint e a chave de API são definidos na entrada `restPkiNg` do [*config.php*](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/php/plain/config.php). ### Java Adicione ao seu projeto o pacote `com.lacunasoftware.restpki:restpkicore-client`, do Maven Central. Ele requer o Java 8 ou posterior. Com o Gradle, no *build.gradle*: ```groovy repositories { mavenCentral() } dependencies { implementation 'com.lacunasoftware.restpki:restpkicore-client:1.4.0' } ``` Com o Maven, no *pom.xml*: ```xml com.lacunasoftware.restpki restpkicore-client 1.4.0 ``` Consulte o [Maven Central](https://central.sonatype.com/artifact/com.lacunasoftware.restpki/restpkicore-client) para saber qual é a versão mais recente. > **Aviso** > > Não confunda com o `com.lacunasoftware.restpki:restpki-core-client`, um pacote mais antigo que não é mais atualizado. O pacote é de código aberto, hospedado no [GitHub](https://github.com/LacunaSoftware/RestPkiNGJavaClient): fique à vontade para fazer um fork se precisar personalizá-lo. Obtenha um `RestPkiService` de `RestPkiServiceFactory.getService()`, passando um `RestPkiOptions` com o **endpoint** e a **chave de API**: ```java import com.lacunasoftware.restpkicore.RestPkiOptions; import com.lacunasoftware.restpkicore.RestPkiService; import com.lacunasoftware.restpkicore.RestPkiServiceFactory; RestPkiOptions options = new RestPkiOptions(); options.setEndpoint("https://core.pki.rest/"); options.setApiKey(System.getenv("RESTPKI_API_KEY")); RestPkiService service = RestPkiServiceFactory.getService(options); ``` Neste exemplo, a chave de API vem da variável de ambiente `RESTPKI_API_KEY`, o que a mantém fora do código. Se a aplicação acessa a internet por um proxy, defina-o com `options.setProxy()`. #### Cultura Para definir a cultura das respostas da API, chame `setCulture()`: ```java options.setCulture("en-US"); ``` #### Erros Os métodos do `RestPkiService` declaram `throws Exception`. Estas são as exceções que eles lançam, todas no pacote `com.lacunasoftware.restpkicore`: Exceção | Quando ------------------------------- | ------ `RestPkiException` | A API rejeitou a requisição (HTTP 422). `getErrorCode()` retorna o [código de erro](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/error-codes) `ValidationException` | Um certificado ou uma assinatura não passou na validação `RestResourceNotFoundException` | O recurso não foi encontrado (HTTP 404) `RestErrorException` | Qualquer outro erro HTTP. `getStatusCode()` retorna o código de status HTTP (veja [Códigos de status HTTP](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#http-status-codes)) `RestUnreachableException` | Não foi possível acessar o endpoint #### Exemplos em Java No nosso [repositório de exemplos](https://github.com/LacunaSoftware/PkiSuiteSamples/tree/master/java/springmvc), os controllers cujo nome termina em `CoreController`, como `SignatureSessionRestCoreController`, usam o Rest PKI Core. O endpoint e a chave de API são definidos em `rest-pki-core`, no *application.yml*. ### Chamando a API diretamente As APIs do Rest PKI Core são RESTful, recebem e retornam JSON e, por isso, são fáceis de chamar em qualquer linguagem de programação moderna. Se a aplicação usa uma linguagem sem biblioteca cliente, chame-as diretamente: * **URL**: acrescente o caminho relativo da API ao **endpoint**. Por exemplo, `api/signature-sessions` na instância SaaS é `https://core.pki.rest/api/signature-sessions` * **Autenticação**: passe a **chave de API** no header `X-Api-Key` de todas as requisições * **Corpo**: envie JSON com o header `Content-Type: application/json` Por exemplo: ```plaintext POST https://core.pki.rest/api/signature-sessions X-Api-Key: MyApp|0f3c... Content-Type: application/json ``` Todas as APIs, com as requisições e respostas, estão descritas na [referência da API](https://core.pki.rest/swagger). Numa instância própria, a referência fica no caminho `swagger` do endpoint, como `https://restpki.suaempresa.com.br/swagger`. #### Códigos de status HTTP A API responde com os seguintes códigos de status HTTP: Código | Significado --------------------------- | ----------- 200 (OK) | A requisição foi bem-sucedida. A resposta depende da API: veja a [referência da API](https://core.pki.rest/swagger) 400 (Bad Request) | A requisição está malformada; por exemplo, falta um campo obrigatório 401 (Unauthorized) | A chave de API está ausente, é inválida ou expirou 403 (Forbidden) | A chave de API é válida, mas a aplicação dela não tem um papel que permita a operação (veja [Escolhendo os papéis](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#roles)) 422 (Unprocessable Entity) | A API rejeitou a requisição, normalmente por causa de um parâmetro que precisa ser corrigido. O corpo é um [ErrorModel](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#error-model) 500 (Internal Server Error) | Ocorreu um erro inesperado. O campo `exceptionCode` do corpo ajuda a diagnosticar o problema: informe-o ao entrar em contato com o suporte #### ErrorModel Quando a API responde com 422 (Unprocessable Entity), o corpo é um `ErrorModel`, chamado `ErrorModelV2` na [referência da API](https://core.pki.rest/swagger), com os seguintes campos: Campo | Tipo | Descrição ------------------- | -------- | --------- `code` | `string` | O código de erro (veja os [códigos de erro](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/error-codes)). Escreva o tratamento de erros com base neste campo `message` | `string` | Descrição do erro, em inglês. Serve para os seus logs, não para os seus usuários, já que não é localizada `details` | `object` | Informações adicionais sobre o erro, quando houver `validationResults` | `object` | Quando o código é `ValidationError`, os resultados da validação do certificado ou da assinatura que falhou Por exemplo: ```json { "code": "SignatureSessionNotFound", "message": "Signature session not found: 00000000-0000-0000-0000-000000000000" } ``` #### Cultura A API observa o header de requisição `Accept-Language`, que muda a cultura dos textos que a API retorna. As culturas suportadas são: * `en-US` (ou apenas `en`) * `pt-BR` (ou apenas `pt`) * `es-ES` (ou apenas `es`) > **Observação** > > As mensagens de erro não são afetadas por esse header; por isso, devem ser registradas no log, e não exibidas aos seus usuários. Para > mostrar um erro a um usuário, associe o `code` dele a uma mensagem própria. ## Faça uma primeira chamada Com as credenciais e a biblioteca cliente prontas, verifique se tudo funciona. Primeiro, verifique o **endpoint**: abra o endereço `api/system/info` do endpoint num navegador, como [https://core.pki.rest/api/system/info](https://core.pki.rest/api/system/info). Esse endereço não exige chave de API e retorna a versão da instância: ```json {"productName":"Lacuna Rest PKI Core","productVersion":"5.0.5 RTM","spaVersion":"...","timestamp":"..."} ``` Depois, verifique a **chave de API** criando uma [sessão de assinatura](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/signature-sessions). Em .NET: ```cs using Lacuna.RestPki.Api.SignatureSessions; var response = await restPkiService.CreateSignatureSessionAsync(new CreateSignatureSessionRequest() { ReturnUrl = "https://localhost:5001/signature-callback", }); // Send the user to response.RedirectUrl ``` Chamando a API diretamente: ```bash curl -X POST "https://core.pki.rest/api/signature-sessions" \ -H "X-Api-Key: YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "returnUrl": "https://localhost:5001/signature-callback" }' ``` A resposta traz o ID da sessão e a URL da página de assinatura dela: ```json { "sessionId": "3fa85f64-5717-4562-b3fc-2c963f66afa6", "redirectUrl": "https://core.pki.rest/..." } ``` Abra a `redirectUrl` num navegador para ver a página em que os seus usuários vão assinar. Se, em vez disso, a chamada falhar: * **401**: a chave de API não foi enviada ou está errada. Verifique se você copiou a chave inteira, incluindo o nome da aplicação antes do `|` * **403**: a aplicação não tem o papel **Operador** (veja [Escolhendo os papéis](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/get-started#roles)) * **Endpoint inacessível**: verifique o endereço do endpoint e se o seu servidor consegue acessá-lo ## Próximos passos * [Sessões de assinatura](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/signature-sessions): permita que os seus usuários assinem documentos numa página hospedada pelo Rest PKI Core * [Assinaturas em duas etapas](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/two-step-signatures): assine na sua própria página com o Web PKI, ou com uma chave guardada no servidor * [Sessões de biometria](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/bio-sessions): prova de vida, cadastro, autenticação e identificação facial e captura de documento * [Webhooks](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/webhooks): seja avisado quando um documento for assinado * [Referenciando arquivos](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/file-referencing): as formas de enviar documentos à API * [Utilitário cliente do Rest PKI](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/client-tool): assine documentos pela linha de comando e a partir de aplicações desktop * [Solicitando carimbos de tempo](https://docs.lacunasoftware.com/articles/rest-pki/core/requesting-timestamps): use o Rest PKI Core como provedor de carimbos de tempo * [Códigos de erro](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/error-codes): os códigos que a API pode retornar **Demonstrações e exemplos** - Demonstração: [Your certificates in the browser](https://try.lacunasoftware.com/pt/web-pki/certificates-in-the-browser) - Demonstração: [Sign a file with Rest PKI Core](https://try.lacunasoftware.com/pt/pki-suite/sign-a-file-rest-pki-core) - Authenticate with a digital certificate using Rest PKI Core: [Java](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/java/springmvc/src/main/java/com/lacunasoftware/pkisuite/controller/AuthenticationRestPkiCoreController.java) - Sign a PDF with Rest PKI Core: [.NET](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/dotnet/mvc/PkiSuiteAspNetMvcSample/Controllers/PadesSignatureRestCoreController.cs) · [Java](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/java/springmvc/src/main/java/com/lacunasoftware/pkisuite/controller/PadesSignatureCoreController.java) · [Node.js](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/nodejs/expressmvc/routes/pades-signature-core.js) · [PHP](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/php/plain/public/pades-signature-rest-core/index.php) · [Python](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/python/flask/sample/views/pades_signature_rest_core.py) · [Ruby](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/ruby/rails/app/controllers/pades_signature_rest_core_controller.rb) - Sign multiple PDFs with Rest PKI Core: [Node.js](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/nodejs/expressmvc/routes/batch-pades-signature-core.js) - Sign a PDF with a server key using Rest PKI Core: [.NET](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/dotnet/mvc/PkiSuiteAspNetMvcSample/Controllers/PadesServerKeyRestCoreController.cs)