Adicione licenciamento ao seu software
Reserve cerca de 15 minutos para proteger uma exportação: configuração, exemplo, integração e teste de recusa. As ferramentas da linguagem devem estar instaladas.
O SDK cuida de requisições, identidade, assinaturas, credenciais, cache e sinais. Forneça a chave do cliente e sua função; não monte HTTP nem salve activation_id manualmente.
- Baixar pacote de integraçãoGere as configurações do produto no console
- Gerar um arquivo exportadoVerificar autorização e resultado da operação
- Integre no aplicativoInicialização, entrada da operação, encerramento
1. Prepare o pacote no console
Abra Início rápido, informe o nome do software, escolha licença vinculada ou flutuante e clique em Criar produto e continuar. O sistema prepara produto, política, licença de teste, chave pública e versão 1.0.0. Escolha a linguagem, baixe e extraia o pacote configurado.
O pacote contém duas configurações:sdk-demo.json contém uma chave de teste para seus testes;product.json contém apenas configurações do produto e chave pública, e pode acompanhar o software.
Na primeira integração, escolha licença vinculada ao dispositivo. O exemplo habilita export sem contador. Produtos existentes precisam da função na política e licença.
2. Verificar o ambiente e exportar um arquivo
Abra o terminal na raiz extraída. Mantenha product.json, sdk-demo.json, start.ps1, start.sh e sdk juntos. Escolha linguagem e sistema e execute. A verificação não ativa a licença.
Sinal de sucesso:Código 0, saída abaixo e um novo licensed-report.txt. Execute sem a opção de teste: o SDK restaura a credencial sem ocupar outra vaga de dispositivo.
License OK: export is available
Export completed: licensed-report.txtInstale as ferramentas ausentes. C/C++ também precisa de arquivos de desenvolvimento libcurl; MinGW aceita -CurlRoot. Aceitar o aviso do navegador não basta: o ambiente deve confiar no certificado do servidor de teste.
3. Integre no aplicativo do cliente
Execute o instalador no projeto. As nove linguagens usam 0.10.0. SHA-256 é verificado antes de instalar ou extrair. Adicione apenas product.json aos recursos.
Instalar offline pelo pacote de integração baixado
Substitua SDK_ROOT pelo caminho absoluto do diretório extraído.
Arquivo executável desta linguagem:. Copie a entrada da operação para seu projeto; Ver o código completo →
| Etapa do aplicativo | O que fazer |
|---|---|
| Inicialização ou tela de ativação | Forneça product.json e a chave do cliente. Após ativação, passe uma chave vazia nos próximos inícios. Aplicativos gráficos ativam online em segundo plano. |
| Botão, atalho, menu ou comando de exportação | Passe a função de exportação a RunFeature. O SDK verifica permissão antes de executá-la. Mantenha o mesmo client ativo. |
| Encerramento do aplicativo | Feche client para parar os sinais. Assentos flutuantes são devolvidos; o registro do dispositivo permanece. |
4. Verificar que a recusa bloqueia a exportação
Confirme que a política exclui licentivo_denied_probe e execute o comando. Espere código diferente de zero e nenhum denied-report.txt. Use um caminho de saída inexistente.
5. Adicionar operações por uso quando necessário
Passe sua função e um ID estável a RunMeteredFeature. O SDK reserva uso, confirma sucesso, cancela falha da operação e registra confirmações pendentes.Ver integração por uso e novas tentativas →
Distribua apenas o SDK necessário e product.json. Cada cliente tem sua chave. Exclua sdk-demo.json, caches, credenciais e chaves API de gestão. cache_path vazio escolhe uma pasta privada por usuário.
Entenda estes três identificadores
| Nome | Usado por | Finalidade |
|---|---|---|
Chave de licença lv_lic_… | O comprador do software | Ative no aplicativo. O código temporário de transferência lv_tmp_… também vai no mesmo campo. |
| ID do produto | SDK / Desenvolvedor | Identifica o produto validado; pode ser distribuído com o aplicativo. |
| Chave API de gerenciamento | O servidor do fornecedor | Automatiza emissão, renovação e gestão de licenças. A ativação no cliente não precisa dela. |
Configure separadamente intervalo de heartbeat e duração offline em Políticas de licença. A validade começa na primeira ativação. Acrescente cotas de recursos, vagas flutuantes e ativação por arquivo offline depois da integração básica.
Sem se cadastrar, você pode abrir Experimentar a demonstraçãopara ver requisições e respostas. Para automatizar emissão, continue em Chave API de gerenciamento.
SDK cliente
Entregue sua função ao SDK: RunFeature para permissões, RunMeteredFeature para contadores. O SDK cuida de requisições, assinaturas, cache e sinais periódicos.
Antes de executar
No console, Início rápidobaixe o pacote configurado. A demonstração usa o arquivo privado sdk-demo.json; no aplicativo real, use product.json, passando a chave do cliente na inicialização. Baixar SDK abaixo fornece código genérico sem suas configurações de produto.
O que significa cada campo da configuração?
{
"base_url": "https://www.licentivo.com",
"product_id": "PRODUCT_UUID",
"license_key": "",
"device_name": "Customer app",
"app_version": "1.0.0",
"trusted_keys": {
"SIGNING_KEY_UUID": "BASE64URL_PUBLIC_KEY"
},
"timeout_seconds": 10,
"allow_http": false
}base_url- URL do servidor de licenças: apenas domínio e porta, sem
/api/v1. Para testes locais, usehttps://127.0.0.1:8080. product_id- ID do produto deste aplicativo. Deve corresponder ao produto da licença.
license_key- Deixe vazio em product.json. Passe a chave do cliente para OpenWithLicense:
lv_lic_…ou um código de transferência:lv_tmp_…; isso não modifica a configuração compartilhada. app_version- Versão atual no formato principal.secundária.correção, como 1.0.0. Obrigatória com intervalo de versões ou manutenção. Valide online novamente após mudar a versão.
device_name- Nome do dispositivo exibido no console. Ajuda a reconhecê-lo, mas não determina sua identidade.
trusted_keys- ID da chave de assinatura e chave pública do produto. Distribua com o aplicativo ou atualização autenticada. Nunca confie numa chave fornecida por resposta desconhecida.
cache_path- Omita ou deixe vazio para usar um diretório privado por usuário, ou escolha um arquivo privado do aplicativo.
timeout_seconds- Tempo limite por solicitação: 10 segundos por padrão, de 1 a 120. Falhas temporárias de rede permitem até duas tentativas.
proxy_url- URL de proxy opcional. Java usa proxy HTTP; Node.js precisa de undici quando há proxy configurado. A verificação de certificados permanece ativa.
allow_http- Em produção, mantenha o valor
false, usando HTTPS. Para testes locais, defina comotrue, apenas para localhost ou endereços de loopback.
Não é necessário informar device_id: o SDK lê a identidade local. As chaves públicas de product.json podem ser distribuídas; mantenha chaves dos clientes e sdk-demo.json privados.
Escolha sua linguagem
O código corresponde ao arquivo distribuído e gera uma exportação real. Variáveis substituem a entrada de ativação; use sua interface e mantenha client ativo durante o aplicativo.
Instalação comum e versões publicadas
Escolha linguagem e plataforma e execute no projeto. O SDK é distribuído pelo site Licentivo sem conta GitHub. A publicação no GitHub e registros permanece pendente.
Versão: · Pacote com versão · Arquivo de verificação SHA-256 · Manifesto da versão
Windows x64 e Linux x64 estão verificados. A validação física macOS e ARM64 está pendente. Pacotes C/C++ são separados por plataforma e compilador.
Como referenciar o SDK instalado
| Idioma | Integração ao projeto |
|---|---|
| Go | import licentivo "github.com/spf86/licentivo-sdk" |
| Java | implementation(files('.licentivo-sdk/java/v0.10.0/licentivo-sdk-0.10.0.jar')) |
| C / C++ | find_package(Licentivo 0.10 REQUIRED) · target_link_libraries(MyApp PRIVATE Licentivo::C) / Licentivo::CPP |
| C# | using Licentivo; |
| Python | from licentivo import Client |
| Node.js | import {Client} from '@licentivo/sdk' |
| Rust | use licentivo::Client; |
| Ruby | require 'licentivo' |
Mantenha .licentivo-sdk usado por Go, Rust e C/C++ no projeto. Escolha nova versão para atualizar; product.json e caches dos clientes são preservados.
Execute a operação protegida pelo SDK e feche client ao sair.
正在加载代码…Executar este arquivo com o script inicial →
Usar outra chave de cliente ou executar a demo completa
Defina a variável e execute o script sem opção de teste. A chave de licença não é uma chave de API administrativa.
Em caso de sucesso, a saída é License OK: export is available. No aplicativo, obtenha a chave no formulário de ativação. O cliente não precisa de variável de ambiente; o SDK salva a credencial da máquina. Não registre a chave nos logs.
Executar a demonstração completa do pacote
Extraia o ZIP preservando as pastas. Coloque sdk-demo.json na raiz do pacote extraído. Escolha o sistema, abra o terminal nessa pasta e execute:
Esta demo de protocolo serve para diagnóstico avançado. Comece por start.ps1 ou start.sh; os exemplos mantêm o registro do dispositivo no encerramento normal.
Como executar este exemplo de gestão?
Primeiro defina estas variáveis no servidor LICENTIVO_URL e LICENTIVO_API_KEY, informe a URL do servidor de licenças e a chave de gestão completa. O exemplo lista os produtos e mostra o status HTTP e a resposta.
Retorna HTTP 200 contendo data.items, a requisição foi concluída. Para 401, verifique se a chave está completa, expirada ou revogada. Criação e permissões estão em Chave API de gerenciamento.
Executar um exemplo de aplicativo
Os exemplos têm ativação, estado, exportação e liberação do dispositivo. Java, Python e C# usam janelas; os demais, menus no terminal. Digite a chave uma vez, depois deixe vazia para restaurar.
A exportação cria licensed-report.txt. Configure a cota de export na política antes de usar exportação por consumo.
As demos de janela e menu mostram reservas de baixo nível. Use RunMeteredFeature abaixo: as nove linguagens salvam confirmações pendentes. Após falha durante a operação, confira seu resultado.
Como exibir o estado da autorização?
Status e FeatureStatus leem o estado local sem solicitações ou espera pela verificação. Use notificações para atualizar a interface.
| Status | Significado |
|---|---|
active | A última verificação online foi bem-sucedida; a autorização local é válida. |
offline_valid | A assinatura local é válida; ainda não houve confirmação online desde a inicialização. |
verification_required | Nenhuma assinatura utilizável. Ative ou atualize online. |
| expired / revoked / released | O servidor negou a autorização explicitamente. Interrompa operações protegidas. |
quota_exhausted | Esta solicitação excedeu a cota; outros recursos autorizados continuam disponíveis. |
allowed indica a validade local; recursos medidos ainda solicitam unidades. lease_valid_until é o prazo do cache assinado, não o vencimento da licença. code, request_id e retryable indicam erro, referência do log e possibilidade de repetir.
Veja sdk/README.md para métodos, callbacks e pacotes. O site fornece pacotes versionados e instaladores comuns; os registros públicos seguem pendentes.
Onde colocar isso no aplicativo?
| Etapa do aplicativo | O que fazer |
|---|---|
| Ao iniciar ou após informar a chave | Chame OpenWithLicense (construtor e Start em C++). O SDK ativa e inicia heartbeats conforme a política. |
| Antes de recursos pagos | Passe a função a RunFeature; use RunMeteredFeature para contadores |
| Durante a execução | Mantenha client vivo; o SDK envia heartbeats no intervalo da política. |
| Ao sair do aplicativo | Close / Dispose / Destroy para heartbeats, devolve vagas flutuantes e mantém registros vinculados. |
| Quando o usuário desvincula | Chame Deactivate e feche client. |
Os nomes indicam operações; use os métodos exatos do exemplo da sua linguagem. Para heartbeats, cache offline e atualização online, veja Heartbeats e acesso offline.
Chave API de gerenciamento
Use uma API Key de gestão para emitir licenças pelo sistema de pedidos ou ler dados de autorização no servidor. Ela representa seu espaço de fornecedor.
Qual chave o cliente precisa?
| Credencial | Destinatário | Para que serve |
|---|---|---|
lv_api_…Chave API de gerenciamento | Seu servidor | Criar produtos, políticas e licenças; ver dispositivos, uso e auditoria |
lv_lic_…Chave de licença | Aplicativo do cliente | Ativar, validar, enviar heartbeats e liberar dispositivo |
| Chave pública do produto | Distribuir com o cliente | Verificar assinatura da licença do servidor |
Para validar a licença no software do cliente, basta a chave de licença. A API Key de gestão controla todo o espaço; não a coloque no software cliente ou em páginas públicas.
Criar uma chave
- Entre como Owner do espaço e abra API Key e clique em Criar API Key.
- Dê um nome conforme o uso, como “Pedidos”. Escolha Somente leitura para consultar ou Leitura/escrita para criar ou alterar licenças. Validade: 1–365 dias.
- Copie a chave completa ao salvar; ela aparece apenas uma vez. Guarde na configuração privada do servidor ou em uma variável de ambiente.
Enviar a primeira requisição de gestão
Este exemplo lê a lista de produtos. Defina LICENTIVO_URL como URL do servidor de licenças e defina LICENTIVO_API_KEY como chave completa criada e execute:
curl "$LICENTIVO_URL/api/v1/products?limit=25" \
-H "Authorization: Bearer $LICENTIVO_API_KEY"Sintaxe para Bash/macOS/Linux. No Windows PowerShell, use curl.exe; a variável de ambiente é $env:LICENTIVO_URL e $env:LICENTIVO_API_KEY. Exemplos completos em nove linguagens também estão em Opção API Key de gestão no servidor na página SDK.
Sucesso retorna HTTP 200 com data.items. Requisições Bearer Key dispensam cookies de login e CSRF.
Permissões e invalidação
Chaves de leitura consultam recursos; leitura/escrita também cria e altera produtos, políticas e licenças. Contas, equipes, configurações e pagamentos exigem login de uma conta autorizada, não uma chave de gestão.
Revogue no console chaves vazadas ou sem uso. Para substituir, clique em Rotacionar; a antiga deixa de funcionar imediatamente. Depois atualize a configuração do servidor.
A cota API do plano conta ativação, validação, heartbeat e liberação. Estas requisições de gestão não entram na cota.
API de produtos e licenças
Emita licenças no seu servidor após o pedido: crie o produto e a política, depois uma licença por cliente. Produto e política normalmente são configurados uma vez.
Crie primeiro no painel um Chave API de gerenciamento. Os exemplos abaixo usam Authorization: Bearer 你的管理Key; mantenha esta chave no servidor do fornecedor.
Use data.id do produto como product_id e da política como policy_id. Ao emitir, salve data.id e data.key da licença. A chave completa retorna uma vez; key_prefix da lista não ativa o software.
Para licença por prazo antes da ativação,expires_at e first_activated_at são null. Prazo começa na primeira ativação; troca não renova a duração.
Gestão posterior
| Método e caminho (sem /api/v1) | Uso e corpo da requisição |
|---|---|
GET /products | Lista os produtos. Na resposta, data.items é a lista de registros e data.total é a quantidade total. |
GET /licenses/{id} | Consultar licença, primeira ativação e expiração. |
POST /licenses/{id}/renew | Renovar, como {"days":30}. Mantém a licença original. |
POST /licenses/{id}/revoke | Revogar; corpo {}. |
GET /products/{id}/public-keys | Leia chaves públicas sem autenticação. Fixe chaves confiáveis ao distribuir SDK. |
GET /activations | Ver vínculos de dispositivos e sessões. |
Paginação usa limit=25&offset=0, limit no máximo 100. Outros parâmetros e estruturas em Arquivo OpenAPI; veja o tópico à esquerda correspondente ao modelo.
Como chamar com sessão do navegador?
Requisições de escrita com cookies exigem X-CSRF-Token. Faça GET /api/v1/auth/csrf e use data.csrf_token nesse cabeçalho. Bearer Key dispensa CSRF.
Chamadas de licença do SDK
Escolha a linguagem e a operação e chame o SDK. Ele cuida da ativação, identidade do dispositivo, assinaturas, cache, heartbeats e reserva, confirmação e cancelamento de uso.
Nos exemplos, client vem da inicialização, path é o caminho de exportação e exportReport / export_report é sua função de negócio. jobID é o ID estável salvo pelo aplicativo.
Ver o código completo → · Início rápido · Ver integração por uso e novas tentativas →
O SDK executa o negócio apenas com permissão. RunFeature não desconta uso; RunMeteredFeature reserva, confirma após sucesso e cancela após falha. Repetir a tarefa original conclui a confirmação sem refazer o negócio.
Expandir solicitações e respostas HTTP (clientes personalizados ou diagnóstico)
O protocolo abaixo já está implementado nos SDKs. Aplicações que usam estes nove SDKs não precisam implementá-lo novamente.
As oito interfaces autenticam licença e dispositivo, sem cookies, CSRF ou chave administrativa. Sessões flutuantes são liberadas ao sair; dispositivos vinculados mantêm registro.
Como verificar acesso após ativação, validação ou heartbeat?
- Confirme HTTP 200 e leia
data.activation_id. Inclua este ID em validações, heartbeats, contagens e desativações seguintes. - Verifique com a chave pública confiável do produto
data.leasee confira produto, dispositivo, validade e funções. Apenas decodificar payload em JSON não comprova a licença. - O SDK automatiza os dois primeiros passos. RunFeature verifica acesso antes da operação; RunMeteredFeature gerencia reserva, confirmação e cancelamento para contadores.
O SDK guarda o cache assinado e envia heartbeats conforme a política. Não apague cache válido por um timeout. Com revogação, liberação ou expiração explícita, bloqueie funções protegidas conforme o resultado do SDK.
O que significam campos do payload decodificado?
O exemplo apenas explica os dados. Ao verificar a assinatura por conta própria, use os bytes originais de payload; não reordene nem serialize o JSON antes.
Tentativas, heartbeats e cobrança
Obrigatório para ativação, desvinculação e contagem Idempotency-Key, até 80 caracteres sem espaços. Gere um valor por operação; em tentativas da mesma operação, mantenha valor e corpo. Opcional para validação e heartbeat; o SDK gerencia seus IDs.
Cada ativação, validação, heartbeat ou desvinculação bem-sucedida usa uma chamada API. Falhas e repetições idempotentes não contam de novo; CheckFeature é local. Consume desconta usos da função, não essa cota API; quantity é a quantidade consumida.
Intervalo, duração offline e permanente seguem Políticas de licença.payload.expires_at é o vencimento do cache assinado atual, não o da licença. Consulte os detalhes da licença para a data final.
Heartbeats e acesso offline
As duas opções ficam nas políticas de licença, mas definem coisas diferentes: frequência de contato online e duração de uso sem alcançar o servidor.
Intervalo: frequência de validação
Defina Intervalo de heartbeat (segundos) como 600, o SDK envia um heartbeat aproximadamente a cada 10 minutos durante a execução. Cada sucesso obtém as regras atuais e atualiza o cache local da licença.
Informe 600–86400 segundos. Informe 0 desativa os heartbeats agendados. O aplicativo ainda pode verificar ou atualizar manualmente. O agendamento adiciona atraso aleatório de 0–10%; o intervalo nunca fica abaixo de 600 segundos.
Com licença vinculada ao dispositivo e cache válido, o acesso é restaurado e atualizado online em segundo plano, mesmo sem temporizador. Licenças somente online ou flutuantes aguardam o servidor.
Tempo offline: quanto usar sem o servidor
Modo offline tem três opções e não altera o intervalo de heartbeat.
- Permitir por duração definida
- Com 24 horas, o cache assinado vale até 24 horas desde a última validação online bem-sucedida. O software funciona durante quedas de rede ou falhas temporárias nesse período. Depois, precisa validar online.
- Fallback offline não permitido
- A inicialização exige sucesso no servidor; cache em disco não libera acesso após falha. A assinatura curta obtida em execução vale no máximo
max(10, 心跳间隔)segundos; o aplicativo deve continuar validando e verificando permissões. - Permitir acesso offline permanente
- A assinatura local pode ser usada por longo prazo, mesmo sem rede. Uma licença de 30 dias continua expirando em 30 dias; offline permanente não torna a licença perpétua.
A API usa offline_mode representa estas três opções, na ordem limited, none, permanent. Com duração offline definida,offline_seconds é 1–31536000 segundos; use 0 nos outros dois modos.
Como funcionam estas combinações?
| Heartbeat / configurações offline | Comportamento real |
|---|---|
| 10 minutos / 24 horas | Valide a cada 10 minutos online. Offline, use por até 24 horas desde a última validação bem-sucedida |
| 10 minutos / offline permanente | Tenta heartbeat a cada 10 minutos, atualiza regras ao conseguir e usa assinatura válida sem conexão. |
| 0 / offline permanente | Com cache válido, inicie sem requisições agendadas. Validação ou atualização explícita ainda acessa o servidor |
| 0 / 24 horas | Sem heartbeat agendado, mas cache expira. O aplicativo agenda validação; desativar não estende tempo offline. |
Defina tempo offline maior que o intervalo. Com heartbeat por hora e só 1 minuto offline, a assinatura expira antes do próximo; o aplicativo precisa validar separadamente.
Alterar a política atualiza licenças existentes?
Sim. Alterações de heartbeat ou offline valem para licenças antigas e novas vinculadas na próxima ativação, validação ou heartbeat bem-sucedido. O SDK substitui o cache assinado. A mesma Idempotency-Key continua retornando o resultado original.
Um dispositivo offline mantém as regras assinadas existentes. Reconectar não atualiza o cache por si só; uma requisição precisa ter sucesso. O aplicativo pode atualizar quando a rede voltar.
Dias válidos, limite de dispositivos e funções ficam em cada licença. Alterar a política não os reescreve automaticamente. Modifique os direitos na página Licenças.
Atualização online explícita
Esses métodos sempre tentam o servidor, mesmo com offline permanente e heartbeat desligado. Sucesso atualiza a assinatura. Falha de rede informa erro mas mantém cache válido. Revogação ou liberação explícita apaga o cache.
| Idioma | Como chamar |
|---|---|
| Go | client.RefreshOnline(ctx) |
| Java | client.refreshOnline() |
| C | ln_refresh_online(client) |
| C++ | client.RefreshOnline() |
| C# | await client.RefreshOnline() |
| Python | client.refresh_online() |
| JavaScript | await client.refreshOnline() |
Uma atualização bem-sucedida conta como uma ativação API. Se a política ativar heartbeat antes desligado, chame StartHeartbeat da linguagem para iniciar o agendamento. Offline, o dispositivo não recebe revogação ou liberação.
Vínculo de dispositivos
Com licença de um dispositivo, copiar o software e cache para outro computador comum não transfere a autorização original.
Como o SDK identifica o computador?
Ao iniciar, o SDK lê a identidade do sistema e calcula o hash com o ID do produto. A assinatura do servidor inclui esse hash, também conferido localmente.
Windows lê MachineGuid, Linux machine-id e macOS IOPlatformUUID. Só envia o hash calculado, não a identidade bruta. O campo antigo da configuração device_id não substitui identidade local real.
O que acontece ao copiar os arquivos de A para B?
- A recebe assinatura vinculada ao hash de A.
- B lê identidade própria, obtém hash diferente e rejeita cache de A.
- B precisa ativar online. Com limite de um dispositivo e A ainda vinculado, o servidor recusa B.
Como o cliente troca de computador?
O cliente desvincula o computador antigo e ativa o novo. Se o antigo quebrou, libere em Ativações de dispositivos no console. A troca não reinicia o vencimento.
Reinstalar o sistema pode mudar sua identidade e exigir ativação como novo dispositivo. Clonagem completa, identidade falsa ou cliente alterado são ataques mais fortes; o hash sozinho não garante proteção.
Com offline prolongado, a assinatura de A não sabe imediatamente que foi liberada. Uma requisição bem-sucedida atualiza o estado. Quanto maior o período offline, mais demora a restrição remota.
Hash de dispositivo entre linguagens
SHA256(UTF8(
"LicenovaDevice/v2\n"
+ lower(product_id) + "\n"
+ lower(trim(OS_machine_identity))
))Cotas e cobrança
Cota de dispositivos conta máquinas usadas; API conta requisições bem-sucedidas. São medidas distintas; número de máquinas não determina chamadas API.
Quais operações contam na cota API?
| Ação | Contabilizado? |
|---|---|
| Ativação, validação, heartbeat ou liberação bem-sucedidos | Cada sucesso conta uma vez; heartbeats no mesmo dia contam separadamente. |
| Falhas, como chave inválida ou cota insuficiente | Não conta |
| Tentar com o mesmo Idempotency-Key e retornar resultado original | Não conta novamente |
| CheckFeature local ou verificação do cache assinado | Não conta; sem requisição ao servidor |
| Consultar ou emitir licenças com API Key de gestão | Não incluído nesta cota API de execução |
Requisições repetidas contam o dispositivo mais de uma vez?
Não. No período, o mesmo dispositivo do mesmo produto conta uma vez, mas cada heartbeat bem-sucedido conta API. Liberar não apaga uso anterior.
Exemplo: 100 dispositivos, 8 horas por dia, 22 dias por mês, heartbeat a cada 10 minutos. Só heartbeats geram 105.600 chamadas. Some 100 ativações e uma validação extra por dispositivo por dia, totalizando 107.900 chamadas.
Validações extras são hipóteses; o uso real depende do aplicativo. Em Estimador de uso online ajuste dispositivos, tempo e intervalo.
Como o excedente do plano é cobrado?
Com 100.000 chamadas e 0,0001 USD por extra: 120.000 chamadas bem-sucedidas geram 20.000 extras e uma taxa de 2 USD.
Excedentes permitidos debitam saldo pelo preço do administrador. O total acumulado é arredondado a centavos e só a diferença nova é cobrada, evitando cobrança repetida por arredondamento.
Excedente de dispositivos é separado: dispositivos extras × preço unitário. Limite rígido recusa o excedente correspondente; saldo insuficiente recusa a próxima requisição cobrável. Recusas não aumentam uso.
API ilimitada não tem taxa excedente. Zero significa nenhuma chamada grátis; a regra excedente vale desde o primeiro sucesso. Cotas, preços e limites estão em Plano atual, estes números são apenas exemplos.
Quando começam a duração e a cota?
Compre 1, 3, 6 ou 12 meses. Pague o total uma vez; o plano começa após o pagamento.
As cotas são renovadas mensalmente desde a ativação. Início em 31 de janeiro renova no último dia de fevereiro e em 31 de março. Não acumula.
Sem compra, valem regras padrão por mês UTC. Dispositivos usam fatura mensal; excedente API debita saldo imediatamente. Com plano comprado, valem cotas do período, sem somar as padrão.
Recusa por cota ou saldo não invalida a assinatura offline, que segue suas regras originais. O fornecedor pode liberar dispositivos no console sem usar cota API de execução.
Vagas flutuantes
Licença flutuante limita programas em execução simultânea. Serve para pessoas que compartilham o software em horários diferentes, sem licença por computador.
Exemplo
Com 100 computadores e 10 vagas, os primeiros 10 programas iniciam; o 11º recebe “Sem vagas”. Sair e fechar o SDK normalmente libera a vaga. Dois programas no mesmo computador ocupam duas vagas.
Defina na política
Escolha assentos flutuantes e limite de 10. Intervalo mínimo de heartbeat: 600 s; concessão maior, por exemplo 1200 s. Heartbeats renovam; após falha ou desconexão, a expiração libera o assento.
Licença flutuante permite breve desconexão dentro da concessão. O tempo offline é limitado por ela; não permite offline permanente nem primeira ativação totalmente offline por arquivo.
O que mais o código deve tratar?
Use Open/Start e o fechamento normal. O SDK cria um ID de sessão por client. Não crie um client por exportação; mantenha um até encerrar o programa.
Cache flutuante antigo não restaura vaga ao iniciar de novo. Se a concessão expirou, ative novamente e obtenha vaga antes de retomar.
Ativação offline
Em computador sem rede, use arquivo de solicitação e resposta assinada para a primeira ativação. Leve a solicitação por USB a um computador online.
Etapas
- No computador alvo, carregue a configuração, chame OfflineRequest("activate") e salve o arquivo. A geração não acessa o servidor.
- No computador online, abra Ativação por arquivo offline, envie a solicitação e baixe a resposta. O cliente final também pode usar seu portal.
- Leve a resposta de volta e chame ImportOffline com solicitação e resposta originais. O SDK verifica assinatura, ID, versão e identidade local, depois salva o cache.
- Confira a autorização com CheckFeature. Computador offline não precisa de heartbeat online; a política define a duração offline.
Ativação por arquivo exige licença vinculada que permita offline. A solicitação vale 30 dias. A licença temporária começa na aprovação do servidor, que não sabe quando a resposta será importada.
Como desvincular offline?
No computador original, gere OfflineRequest("deactivate"). O SDK apaga primeiro o cache; depois envie ao fornecedor ou portal. Apagar não prova que não existam cópias antigas. Para bloqueio rápido, exija validação online periódica.
Nomes por linguagem
| Idioma | Gerar solicitação | Importar resposta |
|---|---|---|
| Go | OfflineRequest("activate") → []byte | ImportOffline(requestBytes, responseBytes) |
| Java | offlineRequest("activate") → texto JSON | importOffline(requestText, responseText) |
| JavaScript | offlineRequest("activate") → object | importOffline(requestObject, responseObject) |
| C | ln_offline_request(client, "activate") | ln_import_offline(client, requestText, responseText) |
| C++ / C# | OfflineRequest("activate") → texto JSON | ImportOffline (texto em C++, bytes em C#) |
| Python | offline_request("activate") → dict | import_offline(requestDict, responseDict) |
Em C, libere o texto retornado com ln_free_string. Passe o conteúdo do arquivo de resposta, não o invólucro data da API web.
Limites de uso de recursos
Permissão para exportar difere de 500 exportações mensais. RunFeature verifica acesso; RunMeteredFeature confirma uso após sucesso.
Permitir 500 exportações por mês
Adicione export às funções e uma cota: export, 500, Mensal. Por padrão, após acabar, recusa o uso. Para permitir excedente, defina seu máximo; o sistema registra para seu sistema de pedidos.
Cotas diárias e mensais reiniciam à meia-noite UTC; acumuladas não reiniciam. Alterar a cota não apaga o uso consumido.
Confirmar o uso após exportar com sucesso
Passe sua função ao SDK. Novas tarefas usam novos IDs; novas tentativas mantêm ID, recurso e quantidade. Processos diferentes não devem executar o mesmo ID simultaneamente.
| Idioma | Chamada de operação por uso |
|---|---|
| Go | client.RunMeteredFeature(ctx, "export", 1, jobID, exportReport) |
| Java | client.runMeteredFeature("export", 1, jobID, this::exportReport) |
| Node.js | await client.runMeteredFeature("export", 1, jobID, exportReport) |
| Python | client.run_metered_feature("export", 1, job_id, export_report) |
| C# | await client.RunMeteredFeature("export", 1, jobID, ExportReport) |
| C++ | client.RunMeteredFeature("export", 1, jobID, exportReport) |
| Rust | client.run_metered_feature("export", 1, &job_id, || export_report())? |
| Ruby | client.run_metered_feature("export", 1, job_id) { export_report } |
| C | ln_run_metered_feature(client, "export", 1, job_id, export_report, context) |
Configure a cota export primeiro. Adicione -Metered -OperationID export-job-001 no Windows ou --metered --operation-id export-job-001 no Linux/macOS.
Se a operação tiver sucesso mas a confirmação falhar, a repetição só confirma. Falha durante a operação bloqueia nova execução automática. Confira o resultado persistido e use ResolveMeteredFeature para confirmar ou cancelar. Uso remoto e operação local não são uma só transação.
Quando precisar controlar as reservas
- Crie e salve um ID de tarefa para esta exportação.
- Reserve uma unidade e exporte só após pending. committed indica que já terminou; não execute novamente.
- Após exportar com sucesso e salvar o resultado, chame Commit para confirmar o uso.
- Se a exportação falhar antes de concluir, chame Cancel para liberar a reserva sem consumir unidades.
Reservas duram 15 minutos por padrão, reduzidos na virada do período UTC. Na API, reservation_seconds aceita 30–3600 segundos.
| Idioma | Reservar | Confirmar / Cancelar |
|---|---|---|
| Go | Reserve(ctx, "export", 1, jobID) | Commit / Cancel(ctx, hold.ID, jobID) |
| Java / Node.js | reserve("export", 1, jobID) | commit / cancel(id, jobID) |
| C | ln_reserve(client, "export", 1, jobID) | ln_commit / ln_cancel(client, id, jobID) |
| C++ / C# | Reserve("export", 1, jobID) | Commit / Cancel(id, jobID) |
| Python | reserve("export", 1, jobID) | commit / cancel(id, jobID) |
Como interpretar os campos da resposta?
| Campo | Significado |
|---|---|
| reservation_id / operation_id | ID da reserva e ID original da tarefa; reutilize os mesmos valores nas tentativas. |
| status / expires_at | Estado e prazo: pending aguarda conclusão, committed foi debitado, canceled foi liberado, expired venceu. |
| consumption.used / reserved | Usos confirmados no período / unidades reservadas por todas as tarefas válidas. |
| consumption.limit / remaining | Cota básica / unidades básicas disponíveis. remaining = max(0, limit - used - reserved), sem o excedente permitido. |
| consumption.quantity / overage | Unidades desta tarefa / unidades confirmadas acima da cota básica; não há cobrança ao cliente. |
| consumption.period / reset_at | Período UTC / próxima reinicialização; cotas vitalícias têm reset_at = null. |
Veja corpos de solicitação, respostas e tipos de campos em Reserve, Commit e Cancel na referência da API de execução.
Após o sucesso, não cancele nem exporte de novo. Guarde IDs e resultado e repita Commit. Se a reserva expirou, mantenha a tarefa para conciliação. O consumo remoto e a operação local não formam uma transação atômica.
Consume registra uso imediatamente. Use reservas para não contar operações que falharam. Todos os endpoints de uso exigem conexão e não entram nas quatro operações API cobradas pela plataforma.
Versões e manutenção
Compra perpétua permite uso contínuo, mas não garante upgrades grátis para sempre. A manutenção define versões elegíveis pela data de publicação.
Comprar versão atual, um ano de atualizações incluído
Defina Perpétua e 365 dias de manutenção, desde a primeira ativação. Publique 1.0.0, 1.1.0 etc. em Versões do software com datas reais.
Versões publicadas durante a manutenção continuam utilizáveis. Novas posteriores são recusadas, antigas continuam. Após renovar, estenda em Direitos e cliente da licença.
Como o aplicativo informa sua versão?
Preencha app_version em sdk-demo.json, como 1.1.0. Com manutenção, publique antes no console. Só aceita versões de três números, como 1.2.3. A data publicada não pode mudar para preservar direitos vendidos.
Para limitar a 1.x, defina 1.0.0–1.999.999 sem manutenção. Após atualizar, obtenha online a assinatura da nova versão; cache antigo não a autoriza.
Disponibilizar download
Versões podem incluir URL HTTPS e SHA-256. O portal mostra apenas versões elegíveis. Os registros fornecem links; não enviam instaladores nem instalam atualizações automaticamente.
Portal do cliente
Clientes consultam licenças, dispositivos e desvinculam sem acessar o console do fornecedor.
Fornecedor associa primeiro o e-mail do cliente
Informe e-mail ao emitir ou em Direitos e cliente. Envie o Portal do cliente ao cliente. Ao informar esse email, recebe um link de login único, válido por 15 minutos. A sessão dura 24 horas.
O cliente vê só licenças desse email, não gestão de produtos, faturas ou dados de outros clientes. Configure primeiro o serviço de email nas opções do administrador.
E se o cliente perdeu a chave ao trocar de computador?
- O cliente informa o email vinculado à licença e abre o link recebido. O link apenas faz login; não desvincula dispositivos.
- Em Meus dispositivos / sessões, escolha antigo, Desvincular e trocar e confirme.
- A página mostra código temporário, válido por até 15 minutos e uma ativação bem-sucedida. O cliente pode copiar ou escolher receber por email.
- No novo computador, abra o aplicativo e informe o código temporário. O SDK identifica o dispositivo, vincula a licença original e salva a credencial. Reinícios e heartbeats usam a credencial; expirar o código não afeta a ativação.
Só o vínculo muda. ID, vencimento original, funções, cliente e usos consumidos permanecem; não há nova licença. O novo dispositivo deve atender à política e ter uma vaga disponível.
O que o fornecedor precisa alterar?
Atualize para o SDK atual. O campo da chave de licença também aceita lv_tmp_ códigos temporários; coloque em license_key é suficiente; Start, validação e heartbeat funcionam normalmente. O SDK salva a credencial do dispositivo em um cache privado;cache_path pode ficar vazio. Guarde este arquivo no diretório de dados do usuário atual; não o distribua com o instalador.
Após resgate, o aplicativo pode limpar license_key vazio; mantenha produto, chaves e cache_path, o SDK restaura a credencial ao reiniciar. O cliente não precisa guardar ou repetir o código temporário. Até o resgate ter sucesso, mantenha a entrada para repetir após uma desconexão.
Se código expirar ou página for fechada
Entre novamente para ver códigos sem uso. Se um código não usado expirar, peça outro ao lado do dispositivo liberado, sem novo consumo de troca. Código usado não pode ser resgatado nem repetido do registro antigo para contornar limites. Para outra troca, desvincule o dispositivo atual.
Se o novo computador está totalmente offline
No novo computador, informe o código e exporte a solicitação pelo SDK. Antes de expirar, leve a um computador online, gere a resposta no portal e importe no novo. A política deve permitir ativação offline vinculada. O prazo original permanece; proteja a resposta com autorização e credencial da máquina.
Limites de desvinculação e computador antigo
Defina liberações pelo cliente por licença e mês UTC. Zero desativa novas desvinculações no portal. Cliques repetidos, consultas e reemissão de código não usado vencido não contam mais. A regra cobre portal e solicitações offline do cliente, não liberação manual do fornecedor ou chamadas com a chave original.
Desvincular remotamente bloqueia a próxima validação online. Cache offline antigo dura até validar ou expirar. Cache permanente não pode ser desativado remotamente de imediato; use verificações periódicas para revogação rápida. Cópias normais de configuração, credencial e cache em outra máquina são recusadas pela identidade diferente.
O portal gerencia o uso da licença. Pedidos e recebimentos das vendas continuam no sistema do fornecedor.
Notificações de eventos
Na ativação, renovação ou revogação, Licentivo pode notificar seu servidor para sincronizar pedidos, clientes e suporte.
Adicionar endereço de notificação
Em Notificações de licença, adicione URL HTTPS e eventos. Ao salvar, o segredo de assinatura aparece uma vez; guarde no servidor receptor. Produção não permite destinos locais ou privados.
Verifique a assinatura após receber
Leia X-Licentivo-Timestamp, X-Licentivo-Event e corpo bruto. Junte timestamp + '.' + ID do evento + '.' + corpo, calcule HMAC-SHA256 com o segredo, prefixe sha256= e compare com X-Licentivo-Signature em tempo constante. Rejeite diferença maior que 5 minutos.
Deduplicate pelo ID. Confira assinatura, coloque na transação ou fila e retorne 2xx após persistir. Duplicatas recebem 2xx sem repetir ações de pedido.
O que ocorre em caso de falha?
Até 8 tentativas automáticas, com intervalos crescentes. O console mostra HTTP, horário e erros, e permite reenvio manual. Evento e operação compartilham transação; envio continua após reiniciar.
Eventos: criação, alteração, renovação, revogação, ativação, liberação, consumo, próximo vencimento, expiração e manutenção. Notificação só inclui prefixo, nunca a chave completa.
Operações em lote e mudanças de política
Emita, renove ou revogue em lote para tratar clientes juntos. Veja o impacto antes de alterar direitos existentes.
Emitir em lote ou importar
Em Licenças, escolha Emissão/importação em lote, produto e política. Informe nome e email por linha ou envie CSV com customer,customer_email. Até 100 linhas. Baixe o resultado e guarde os códigos completos.
Se um item falhar, o lote inteiro não é aplicado. Após timeout, repita sem mudar conteúdo; o ID da requisição devolve o resultado original, sem emitir de novo.
Renovar ou revogar em lote
Marque licenças e escolha Renovar ou Revogar em lote. A caixa do cabeçalho seleciona a página; seleção permanece entre páginas, até 100. Alterar filtros, sair ou atualizar limpa a seleção.
Informe dias adicionais. Não ativadas ganham duração; ativas estendem vencimento; expiradas estendem desde agora. Antes de revogar, expanda e confira clientes. Revogação é irreversível. Membros de leitura não podem executar.
Aplicar nova política a licenças existentes
- Salve novas regras em Políticas de licença.
- Selecione licenças de um produto, clique Aplicar política e escolha a nova.
- Confira duração, dispositivos/vagas, funções, usos e manutenção. Vagas ocupadas acima do novo limite ou dispositivos ativos ao mudar modo exigem resolver os dispositivos primeiro.
- Aplique após confirmar. A próxima validação online recebe nova autorização assinada; cache totalmente offline não muda remotamente.
A prévia vale 10 minutos. Se licença ou política mudar, refaça. Novos dias recalculam vencimento desde a primeira ativação original; confira as datas antes.
Perguntas frequentes
Veja primeiro o código de erro e depois a configuração. Na resposta, request_id ajuda a localizar nos logs. Não inclua chave completa em logs/capturas.
O que verificar se a ativação falhar?
Confira acesso ao servidor, ID do produto, código completo e vínculo da licença ao produto. Antes de implantar, computadores de clientes não podem usar seu 127.0.0.1 ; esse endereço aponta para o computador do cliente.
| Código de erro | Primeiro passo |
|---|---|
LICENSE_INVALID | Confira ID, chave completa e produto da licença |
LICENSE_EXPIRED | Ver validade; fornecedor renova se necessário |
LICENSE_REVOKEDDEVICE_RELEASED | Licença revogada ou dispositivo liberado; cache limpo |
DEVICE_LIMIT_REACHED | Vagas cheias; libere dispositivo ou aumente limite |
API_QUOTA_EXCEEDED | Cota API esgotada; veja período/plano |
API_BALANCE_INSUFFICIENT | Saldo excedente API insuficiente; confira moeda/ambiente |
MONTHLY_QUOTA_EXCEEDED | Limite da plataforma atingido, separado do limite da licença |
IDEMPOTENCY_CONFLICT | Mesmo Key para textos diferentes; nova operação novo Key, retry mesmo corpo |
IDEMPOTENCY_EXPIRED | Resposta/vínculo inválido; confira estado e use Key novo para nova operação |
Por que ainda funciona offline?
Offline, o SDK ainda verifica assinatura, produto, dispositivo, funções e vencimento localmente. Apenas não consulta o servidor. Cache expirado ou recusa explícita de revogação/liberação impede o uso.
Por que falha a verificação da assinatura ou dispositivo?
Chave pública incompatível, cache de outro produto ou copiado para outro computador podem causar falha. Confira trusted_keys usa o ID e a chave pública do produto atual; depois confira se o sistema foi trocado ou reinstalado.
SDK informa clock rollback : veja se relógio voltou. Corrija e atualize online.
Resposta de erro completa
{
"error": {
"code": "LICENSE_REVOKED",
"message": "License was revoked"
},
"request_id": "99999999-9999-4999-8999-999999999999"
}| Campo | Significado e ação |
|---|---|
error.code · string | Identificador estável na lógica; não dependa de message. |
error.message · string | Motivo legível para diagnóstico ou mensagem ao cliente. |
request_id · UUID | ID de requisição para logs; não licença ou Idempotency-Key. |
400/415: corrija campos ou Content-Type; 401: confira a chave; 403: trate o erro de licença indicado; 409: confira cota, sessão ou idempotência; 429: aguarde Retry-After. Repita timeout ou 5xx com intervalo. Em escritas, reutilize ID e corpo originais para não contar duas vezes.
Como ler a resposta JSON?
Resposta de sucesso data e request_id; falhas retornam error.code, error.message e request_id. Guarde código de erro e request_id para diagnóstico.
Para e-mail, pagamento ou implantação, veja Suporte e diagnóstico.
Veja todos os campos da API no Arquivo OpenAPI.