Codificador PEM Base64
Guarde texto do jeito que certificados e chaves são guardados: Base64 padrão em linhas de 64 caracteres entre as marcas -----BEGIN CERTIFICATE----- e -----END CERTIFICATE-----, ou desembrulhe um bloco PEM para recuperar o texto original. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Rótulo
- CERTIFICATE
- Modo de cálculo
- Encode
- Comprimento da linha
- 64
- Bytes
- 205
Privacy-Enhanced Mail (PEM) é o envelope de texto em que quase todo certificado, chave privada e chave pública ainda viaja: um corpo Base64 dobrado em linhas de sessenta e quatro caracteres entre marcadores coincidentes -----BEGIN LABEL----- e -----END LABEL-----. Desenvolvedores colam esses blocos em configs, segredos de CI, secrets TLS do Kubernetes e logs ACME; engenheiros de suporte reempacotam um blob Base64 contínuo para o OpenSSL aceitar; educadores mostram como um cabeçalho CERTIFICATE difere de PRIVATE KEY sem instalar um kit criptográfico completo.
Codifique texto em um bloco PEM com linhas de 64 caracteres
Quando label é omitido, o motor usa CERTIFICATE, que corresponde à intenção de busca mais comum para colagens de certificado; outros rótulos frequentes incluem PRIVATE KEY, RSA PRIVATE KEY, PUBLIC KEY e CERTIFICATE REQUEST.
O motor serializa a string como bytes UTF-8, mapeia esses bytes para o alfabeto Base64 padrão com preenchimento de iguais, dobra o Base64 contínuo em linhas de exatamente sessenta e quatro caracteres com uma linha final mais curta quando necessário, e envolve o corpo entre -----BEGIN LABEL----- e -----END LABEL----- usando o mesmo rótulo nos dois lados. Cargas vazias são legais: você ainda obtém um PEM bem formado com corpo vazio e cabeçalhos coincidentes, útil para testar parsers.
Texto multilíngue e pontuação fazem ida e volta porque o caminho é UTF-8 completo, não um atalho Latin-1.
Decodifique um bloco PEM e trate entrada inválida com segurança
Defina mode como decode e coloque um bloco PEM completo em text, incluindo as linhas BEGIN e END. Espaços em branco no início e no fim ao redor do bloco são tolerados para que colagens multilinha de tickets e documentação ainda funcionem. O motor localiza o primeiro cabeçalho -----BEGIN LABEL-----, lê o rótulo, encontra o rodapé -----END LABEL----- correspondente e rejeita a requisição quando o rodapé falta, quando o rótulo END não é igual ao BEGIN, ou quando um limite de encapsulamento inesperado aparece dentro do corpo.
As linhas do corpo são aparadas e unidas; espaços, tabulações e quebras de linha dentro da região Base64 são removidos, e o alfabeto contínuo é validado com as mesmas regras do Base64 padrão: caracteres ilegais, preenchimentos no meio, mais de dois sinais de igual de padding, ou um comprimento cujo módulo quatro seja um falham com mensagem explícita.
Prefira esta capacidade quando a intenção de busca for o enquadramento PEM—cabeçalhos mais linhas de sessenta e quatro caracteres—e não Base64 bruto sem encapsulamento nem alfabetos URL-safe de cookies que pertencem a codificadores irmãos.
Casos de uso
Normalização de colagens de certificados e chaves
Reempacote cargas Base64 contínuas ou em claro em linhas PEM de 64 caracteres com rótulos BEGIN/END coincidentes para que OpenSSL, secrets do Kubernetes e servidores web aceitem a colagem.
Perguntas frequentes
Como codifico texto como PEM Base64?
O campo result é um bloco PEM multilinha com linhas Base64 de 64 caracteres.
Como decodifico um bloco PEM?
Envie mode decode e coloque o PEM completo (incluindo as linhas BEGIN/END) em text.
Qual comprimento de linha o PEM usa aqui?
As linhas do corpo são dobradas em sessenta e quatro caracteres, o comprimento clássico do PEM em certificados e chaves.
O codificador PEM Base64 é gratuito?
A ferramenta do navegador roda grátis no seu dispositivo.
O que acontece se o PEM for inválido?
A mensagem descreve o problema; a requisição não é cobrada.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/enc/base64-pem \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, PEM!"}'const res = await fetch("https://api.kit.forhosting.com/enc/base64-pem", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello, PEM!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base64-pem",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello, PEM!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base64-pem", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello, PEM!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello, PEM!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base64-pem", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"text": "Hello, PEM!"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base64_pem",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Este codificador PEM Base64 converte nos dois sentidos com um único campo mode: encode transforma texto UTF-8 em um bloco PEM com dobra clássica de linhas; decode remove os cabeçalhos e recupera a carga UTF-8; e rejeita enquadramento malformado, rótulos divergentes e Base64 ilegal com um erro invalid_input claro. O caminho gratuito do navegador e a API pré-paga compartilham o mesmo algoritmo puro, para que lições, documentação e pipelines nunca discordem por uma quebra de linha. O sucesso na API custa US$ 0,002 por item; falhas de validação não são cobradas.
Codifique texto em um bloco PEM com linhas de 64 caracteres
Envie um corpo JSON com o campo de string obrigatório text definido para a carga UTF-8 em claro que você deseja enviar como PEM, deixe mode no padrão encode ou defina mode como encode explicitamente, e opcionalmente defina label com a string de tipo que deve aparecer nos limites de encapsulamento. Aliases opcionais input, value, s, pem e payload são aceitos para o campo text, e direction, op e action para mode, para que clientes gerados e nomes de formulário antigos continuem funcionando. A resposta sempre inclui result com a string PEM multilinha completa, mode encode, label ecoando o tipo resolvido, line_length fixo em sessenta e quatro, base64_body como o Base64 contínuo sem cabeçalhos nem quebras de linha para clientes que precisam das duas formas, e bytes igual ao comprimento UTF-8 antes da codificação para que testes possam afirmar o tamanho da carga.
Decodifique um bloco PEM e trate entrada inválida com segurança
Se você também passar label no decode, ele deve ser igual ao rótulo encontrado no bloco; uma divergência falha com invalid_input para que a automação possa afirmar que recebeu PRIVATE KEY quando um CERTIFICATE foi colado por engano. Após a validação do alfabeto, os bytes são decodificados como UTF-8 com um decodificador fatal, de modo que blobs DER não textuais que não sejam Unicode válido também geram invalid_input em vez de emitir caracteres de substituição que corromperiam logs. O decode bem-sucedido retorna result como a string recuperada, mode decode, label dos cabeçalhos, line_length sessenta e quatro, base64_body como o corpo contínuo, e bytes como o comprimento UTF-8 decodificado. Falhas de validação não são cobradas na API pré-paga, então sondar uma colagem suspeita é barato para operadores e seguro para usuários finais.
Uso da API, preços, fluxos de trabalho e limites práticos
Use a ferramenta gratuita PEM Base64 no navegador para demos em sala de aula, playbooks de suporte e reempacotamentos pontuais de um certificado colado sem instalar OpenSSL. Um fluxo típico codifica um segredo curto de configuração como PEM rotulado para armazenamento em um sistema de tickets e depois o decodifica no serviço receptor com mode decode, afirmando que bytes e label coincidem com o original. Outro fluxo normaliza um corpo de certificado Base64 contínuo que chegou sem quebras de linha: encode não é obrigatório se você já tem PEM, mas decode aceita corpos dobrados ou não dobrados desde que os cabeçalhos BEGIN e END estejam presentes, e você pode recodificar após inspecionar result se precisar de novo da dobra canônica de sessenta e quatro caracteres. Use a API pré-paga do KIT quando um backend, função serverless ou SDK precisar do mesmo passo de encode ou decode sob saldo a US$ 0,002 por item bem-sucedido; validação falha nunca consome saldo após o motor rejeitar a requisição. Combine este endpoint com ferramentas de Base64 simples quando um pipeline precisar tratar tokens sem moldura e chaves envolvidas em PEM, mas mantenha as landings separadas para que cada página corresponda a uma única intenção de busca—codificador pem base64 versus texto para base64. Autores que entregam SDKs podem mapear o campo result direto para um botão de copiar, enquanto label e line_length tornam exemplos OpenAPI autoexplicativos para leitores que só conhecem o formato clássico de arquivo de certificado.
Casos de integração
Checagens golden de CI e documentação
Fixe fixtures de encode e decode para amostras CERTIFICATE e PRIVATE KEY para que a documentação e os testes de integração contínua falhem rápido se o enquadramento PEM mudar.
Suporte e educação
Agentes e estudantes convertem texto para PEM Base64 e de volta no widget gratuito do navegador, com erros invalid_input claros quando faltam cabeçalhos ou os rótulos divergem.