Dígito verificador MEID
Para o corpo de MEID 6C4BFFC0000004 o dígito verificador é 4, e o resultado é 6C4BFFC00000044, com quinze caracteres: a regra de Luhn padrão aplicada na base 16 sobre os dígitos hexadecimais de 0 a 9 e de A a F. Também valida MEIDs completos. 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
- MEID
- 6C4BFFC0000004
- Modo de cálculo
- Compute
- Entrada
- 6C4BFFC0000004
- Dígito verificador
- 4
- MEID
- 6C4BFFC00000044
Aparelhos CDMA e multimodo identificam o rádio com um Mobile Equipment Identifier (MEID): quatorze dígitos hexadecimais que codificam fabricante e série, mais um caractere de verificação opcional na décima quinta posição calculado de forma que um erro de digitação ou uma transposição falhe com bem mais frequência do que parecer outro dispositivo. Esta capacidade calcula esse dígito verificador com a fórmula padrão Luhn mod-16 sobre o alfabeto hex 0-9A-F, ou valida um MEID completo de quinze hex e indica se o caractere final armazenado coincide com o valor recalculado.
Como o dígito verificador MEID é calculado
O corpo de um MEID tem sempre quatorze dígitos hexadecimais. O caractere de verificação opcional é mais um símbolo do mesmo alfabeto 0-9A-F, produzido pelo algoritmo Luhn mod-N com N igual a dezesseis. Cada produto é reduzido com a soma de dígitos em base dezesseis floor(product/16) mais product módulo dezesseis; em seguida todos os valores reduzidos são somados.
O ponto de código de verificação é dezesseis menos essa soma módulo dezesseis, tomado novamente módulo dezesseis, de forma que uma soma já divisível por dezesseis produz o caractere de verificação zero. Ao acrescentar esse único caractere hex obtém-se a string de quinze símbolos usada em etiquetas de inventário, feeds de provisionamento e CSVs de auditoria. A validação é a operação inversa: recalcula-se o caractere esperado a partir dos primeiros quatorze símbolos e compara-se com o décimo quinto.
*. Observe que um dígito verificador válido prova apenas correção aritmética; não prova alocação GSMA, whitelist da operadora nem que o dispositivo não conste como perdido.
Como calcular um dígito verificador ou validar um MEID completo
Envie um campo meid que contenha apenas caracteres hexadecimais após remover separadores opcionais. O modo validate espera exatamente quinze dígitos hex. Essa forma facilita mostrar «você digitou X, esperava-se Y» em uma UI de armazém ou RMA sem uma segunda requisição.
Strings vazias, meid ausente, valores de mode inválidos e comprimentos incorretos (por exemplo treze ou dezesseis dígitos) falham antes de qualquer passagem Luhn e não são faturados. Prefira compute ao criar ou completar um MEID novo para impressão ou provisionamento; prefira validate quando receber um identificador completo de um scanner, um CSV ou um feed de fornecedor e precisar de um portão booleano antes de gravar o registro do ativo.
Onde os dígitos verificadores MEID se encaixam em fluxos reais de dispositivos
Fabricantes de dispositivos e ODMs atribuem campos de série sob um código de fabricante e devem acrescentar o caractere de verificação correto antes da gravação a laser ou das etiquetas de embalagem para que os sistemas de admissão da operadora e da empresa aceitem o identificador no primeiro escaneamento. Operadoras e MVNOs importam CSVs de parceiros com MEIDs de quinze hex e devem rejeitar linhas cujo dígito verificador já não coincida, o que captura tanto edições humanas quanto bugs de um em geradores a montante.
Mesas de gerenciamento de dispositivos móveis empresariais e de RMA permitem que técnicos digitem ou escaneiem um MEID e podem validar ao perder o foco, bloqueando a abertura de garantia até que valid seja true e reduzindo tickets falhos. Gráficas que compõem etiquetas de ativo a partir de corpos MEID de quatorze dígitos chamam o modo compute uma vez por unidade e colocam a string de quinze caracteres sob o gráfico do código de barras.
Não trate um dígito verificador válido como prova de propriedade, autorização de rede ou unicidade no mundo real — ele só prova que a string de quinze símbolos é aritmeticamente correta sob Luhn mod 16, o mesmo critério de honestidade que você aplica a qualquer checksum de equipamento.
Casos de uso
Completar um MEID de quatorze dígitos para impressão ou gravação
Pegue os campos de fabricante e série (quatorze hex), chame o modo compute e imprima ou grave a laser meid sob o código de barras do ativo para que a etiqueta leve um identificador de quinze caracteres válido Luhn.
Auditar colunas de identificadores de dispositivos de parceiros
Valide em lote cada MEID de um CSV de operadora ou ODM e coloque em quarentena as linhas cujo dígito verificador já não coincida com o valor esperado recalculado.
Perguntas frequentes
O que é um dígito verificador MEID?
É o caractere hexadecimal opcional na décima quinta posição de um Mobile Equipment Identifier, calculado a partir dos primeiros quatorze dígitos hex com Luhn mod 16, de modo que erros de um único caractere falhem com bem mais frequência do que parecer outro dispositivo.
O que acontece com caracteres não hex, espaços ou comprimentos errados?
Espaços, hífens, dois-pontos e pontos são removidos para colar com facilidade. Tarefas de validação falhas não são cobradas.
A ferramenta de dígito verificador MEID é grátis?
A ferramenta do navegador é grátis e roda localmente.
Como o dígito verificador do MEID é calculado?
Com Luhn na base 16. Da direita do corpo de catorze dígitos, os valores hexadecimais (A vale 10 e F vale 15) são multiplicados por 2 e por 1 alternadamente, cada produto é reduzido à soma dos seus dígitos na base 16 e o dígito torna o total divisível por 16.
Um dígito verificador MEID válido prova que o celular é legítimo?
Não. Ele só prova que os quinze caracteres estão bem formados pela conta. Não diz nada sobre a alocação do fabricante, a aprovação da operadora, a posse ou se o aparelho foi informado como perdido.
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/meid \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"meid":"6C4BFFC0000004"}'const res = await fetch("https://api.kit.forhosting.com/enc/meid", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"meid": "6C4BFFC0000004"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/meid",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"meid": "6C4BFFC0000004"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/meid", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"meid":"6C4BFFC0000004"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"meid":"6C4BFFC0000004"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/meid", 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
{
"meid": "6C4BFFC0000004"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.meid",
"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
Espaços, hífens e dois-pontos são removidos para colar com facilidade; qualquer outro caractere não hex e comprimentos incorretos são rejeitados com um erro invalid_input claro, sem reescrever lixo em silêncio. Execute grátis no navegador ou chame a API do KIT pelo preço publicado; ambos os caminhos usam a mesma aritmética pura, sem ida e volta de rede e sem armazenar identificadores.
Como o dígito verificador MEID é calculado
Trabalhando da direita do payload de quatorze dígitos, fatores alternados dois e um são aplicados a cada ponto de código de nibble (A vale dez, B onze, até F como quinze). Como o algoritmo é aritmética inteira pura com alfabeto fixo, o mesmo MEID produz sempre o mesmo dígito verificador em cada plataforma — navegador, Worker ou harness de testes offline —, por isso a capacidade é entregue como motor parse de tier A e não como chamada a um modelo.
Como calcular um dígito verificador ou validar um MEID completo
Espaços, hífens, dois-pontos e pontos são removidos para que strings como 6C4B-FFC0-0000-04 colem limpas; qualquer letra restante fora de A-F ou outro símbolo é rejeitada como entrada hex malformada com invalid_input, de modo que um formulário nunca aceite um valor limpo em silêncio. O modo compute é o padrão: forneça exatamente quatorze dígitos hex; o motor devolve check_digit como string hex maiúscula de um caractere, meid como esses quatorze dígitos mais o de verificação, e length quinze. A resposta indica valid true quando o caractere final coincide com o expected_check_digit recalculado, e inclui sempre payload (os primeiros quatorze dígitos), check_digit como enviado, expected_check_digit e o meid canônico formado com payload mais o caractere esperado. Como o caminho é parse puro, sem relógio, fonte aleatória nem rede, a mesma entrada produz sempre o mesmo JSON na ferramenta gratuita do navegador e na API. A US$ 0,002 por solicitação bem-sucedida você pode proteger importações em massa de dispositivos, impressoras de etiquetas e auditorias de arquivos de parceiros sem negociar um nível personalizado.
Onde os dígitos verificadores MEID se encaixam em fluxos reais de dispositivos
Testes de integração e jobs de qualidade de dados recalculam expected_check_digit para cada coluna MEID de uma exportação e colocam em quarentena as divergências antes de chegarem ao HLR de provisionamento ou à blacklist de dispositivos. Em todo fluxo o contrato é o mesmo: só hex, quatorze para compute ou quinze para validate, JSON estruturado testável com goldens, comportamento idêntico grátis no navegador ou com saldo pré-pago do KIT, e falha honesta quando a entrada não é uma string hex MEID bem formada.
Casos de integração
Validar MEIDs escaneados ou digitados na entrada
Quando um scanner de mão ou um formulário enviar quinze hex, chame o modo validate e bloqueie atualizações de inventário ou garantia se valid for false, mostrando expected_check_digit para corrigir um erro de digitação.
Perguntas técnicas
Como calculo um dígito verificador MEID com esta API?
Faça POST com meid igual a exatamente quatorze dígitos hex e mode compute (ou omita mode). A resposta inclui check_digit e meid (a string completa de quinze hex).
Como valido um MEID completo de quinze dígitos hex?
Faça POST com a string hex de quinze caracteres e mode validate. A resposta inclui valid, check_digit, expected_check_digit, payload e o meid canônico.