O número de identificação fiscal (NIF) tem como finalidade identificar em Portugal uma entidade fiscal, contribuinte, por exemplo, em declarações de IRS ou outros impostos ou transações financeiras
É atribuído pela Autoridade Tributária e Aduaneira, organismo do Ministério das Finanças e da Administração Pública, no caso de pessoas singulares e pessoas colectivas não sujeitas a registo no Registo Nacional de Pessoas Colectivas (RNPC).
É atribuído pelo Registo Nacional de Pessoas Colectivas no caso de entidades sujeitas a registo.
Foi instituído pelo Decreto-Lei n.º 463/79, de 30 de Novembro. O Decreto-lei n.º 463/79 foi revogado a partir de 27 de Fevereiro de 2013 pelo Decreto-lei n.º 14/2013, de 28 de Janeiro, que procede à sistematização e harmonização da legislação referente ao Número de Identificação Fiscal.
Este número é ainda utilizado, dentro da União Europeia, para identificar as entidades económicas para efeitos de IVA (VAT identification Number).
Artigo 2.º do Decreto-lei n.º 14/2013, de 28 de Janeiro:
"O Número de Identificação Fiscal, abreviadamente designado por NIF, é um número sequencial destinado exclusivamente ao tratamento de informação de índole fiscal e aduaneira, devendo ser gerado de forma automática em conformidade com as disposições constantes do presente diploma."
O NIF das Empresas é o número fiscal utilizado em Portugal para identificar uma entidade em transacções financeiras e pagamento de impostos (IRC). O termo usado geralmente é NIF (Número de Identificação Fiscal), no entanto o termo correcto é NIPC (Número de Identificação de Pessoa Colectiva).
No contexto português, o NIF (Número de Identificação Fiscal) é um identificador essencial para cidadãos e empresas nas suas relações fiscais. É crucial ter cuidado ao lidar com a senha das Finanças, associada ao NIF. Os cidadãos devem manter um controlo direto sobre as suas credenciais fiscais e ser cautelosos ao partilhar tais informações.
É constituído por nove dígitos, sendo os oito primeiros sequenciais e o último um dígito de controlo.
O NIF pode pertencer a uma de várias gamas de números, definidas pelos dígitos iniciais, com as seguintes interpretações[1]:
O nono e último dígito é o dígito de controlo. É calculado utilizando o algoritmo módulo 11.
O NIF tem 9 dígitos, sendo o último o digito de controlo. Para ser calculado o digito de controlo:
import doctest DIGITOS_NIF = 9 DIGITOS_CONTROLO = 8 def calcular_digito_controlo(digitos: str) -> str: """Calcula o digito de controle de um NIF Ex. 99999999[0] >>> calcular_digito_controlo('99999999') '0' >>> calcular_digito_controlo('74089837') '0' >>> calcular_digito_controlo('28702400') '8' """ if not digitos.isdigit(): raise ValueError("Nem todos os caracteres são digitos") if not len(digitos) == DIGITOS_CONTROLO: raise ValueError(f"Número de digitos diferente de {DIGITOS_CONTROLO}") soma = ( int(digitos[0]) * 9 + int(digitos[1]) * 8 + int(digitos[2]) * 7 + int(digitos[3]) * 6 + int(digitos[4]) * 5 + int(digitos[5]) * 4 + int(digitos[6]) * 3 + int(digitos[7]) * 2 ) resto = soma % 11 if resto == 0 or resto == 1: return "0" return str(11 - resto) def valida_nif(nif: str) -> bool: """Validação do número de identificação fiscal >>> valida_nif('999999990') True >>> valida_nif('999999999') False >>> valida_nif('501442600') True """ if not nif.isdigit() or len(nif) != DIGITOS_NIF: return False return nif[-1] == calcular_digito_controlo(nif[:DIGITOS_CONTROLO]) if __name__ == "__main__": doctest.testmod()
function validateNIF(value) { const nif = typeof value === 'string' ? value : value.toString(); if (nif.length !== 9) return false; if ( !validationSets.one.includes(nif.substring(0, 1)) && !validationSets.two.includes(nif.substring(0, 2)) ) return false; const nifNumbers = nif.split("").map((c) => Number.parseInt(c)); const total = nifNumbers[0] * 9 + nifNumbers[1] * 8 + nifNumbers[2] * 7 + nifNumbers[3] * 6 + nifNumbers[4] * 5 + nifNumbers[5] * 4 + nifNumbers[6] * 3 + nifNumbers[7] * 2; const modulo11 = Number(total) % 11; const checkDigit = modulo11 < 2 ? 0 : 11 - modulo11; return checkDigit === Number(nif[8]); }
public static function validateNIF($nif) { $nif = trim($nif); $nif_split = str_split($nif); $nif_primeiros_digito = array(1, 2, 3, 5, 6, 7, 8, 9); if (is_numeric($nif) && strlen($nif) == 9 && in_array($nif_split[0], $nif_primeiros_digito)) { $check_digit = 0; for ($i = 0; $i < 8; $i++) { $check_digit += $nif_split[$i] * (10 - $i - 1); } $check_digit = 11 - ($check_digit % 11); $check_digit = $check_digit >= 10 ? 0 : $check_digit; if ($check_digit == $nif_split[8]) { return true; } } return false; }
validateNIF <- function(nif) { if (!grepl("\\D", nif)) { mod11 <- strtoi(strsplit(nif,"")[[1]]) %*% c(9:2,0) %% 11 checkDigit <- ifelse(mod11 == 0, 0, ifelse(mod11 == 1, 9, 11 - mod11)) (substr(nif, 9, 9) == checkDigit)[1][1] } else FALSE }
fn validate_nif(pnif: &str) -> bool { let mut nif = pnif.trim(); if nif.chars().count() == 11 { if &nif[..2] == "PT" { nif = &nif[2..]; } else { return false; } } if nif.chars().count() == 9 && nif.parse::<i64>().is_ok() { let mut total = 0 as i32; for n in 2..10 { let ss:String = nif.chars().skip(9-n).take(1).collect(); total += ss.as_str().parse::<i32>().unwrap() * n as i32; } let modulo11 = total % 11; let check_digit = if modulo11 < 2 { 0 } else { 11 - modulo11}; let s_check_digit:String = nif.chars().skip(8).take(1).collect(); let p_check_digit = s_check_digit.as_str().parse::<i32>().unwrap(); return check_digit == p_check_digit; } return false; }
def valid?(nif) digits = nif.digits.reverse return false unless digits.size == 9 mod11 = (0..7).sum { |n| digits[n]*(9-n) } % 11 digits[8] == (mod11 < 2 ? 0 : 11 - mod11) end
func IsValidNif(nif string) bool { // validate length if len(nif) != 9 { return false } // check if all characters are numbers for _, char := range nif { if char < '0' || char > '9' { return false } } // validate prefixes if !func() bool { if strings.ContainsAny(nif[:1], "123568") { return true } if _, ok := map[string]bool{ "45": true, "70": true, "71": true, "72": true, "74": true, "75": true, "77": true, "78": true, "79": true, "90": true, "91": true, "98": true, "99": true}[nif[:2]]; ok { return true } return false }() { return false } // calculate check-digit sum := 0 for i, char := range nif[:8] { v, err := strconv.Atoi(string(char)) if err != nil { return false } sum += v * (9 - i) } rmd := sum % 11 ckd := 0 switch rmd { case 0, 1: ckd = 0 default: ckd = 11 - rmd } // compare the provided check digit with the calculated one compare, err := strconv.Atoi(string(nif[8])) if err != nil { return false } return compare == ckd }
function validateNIF(nif: string) { const validationSets = { one: ['1', '2', '3', '5', '6', '8'], two: ['45', '70', '71', '72', '74', '75', '77', '79', '90', '91', '98', '99'] }; if (nif.length !== 9) return false; if (!validationSets.one.includes(nif.substring(0, 1)) && !validationSets.two.includes(nif.substring(0, 2))) return false; const nifNumbers = nif.split('').map(c => Number.parseInt(c)) const total = nifNumbers[0] * 9 + nifNumbers[1] * 8 + nifNumbers[2] * 7 + nifNumbers[3] * 6 + nifNumbers[4] * 5 + nifNumbers[5] * 4 + nifNumbers[6] * 3 + nifNumbers[7] * 2; const modulo11 = (Number(total) % 11); const checkDigit = modulo11 < 2 ? 0 : 11 - modulo11; return checkDigit === Number(nif[8]); }
public static boolean PT(String number) { final int max=9; //check if is numeric and has 9 numbers if (!number.matches("[0-9]+") || number.length()!=max) return false; int checkSum=0; //calculate checkSum for (int i=0; i<max-1; i++){ checkSum+=(number.charAt(i)-'0')*(max-i); } int checkDigit=11-(checkSum % 11); //if checkDigit is higher than 9 set it to zero if (checkDigit>9) checkDigit=0; //compare checkDigit with the last number of NIF return checkDigit==number.charAt(max-1)-'0'; }
nifvalido ← {(≡⍵=1):'Não é numérico'⋄(⍴10⊥⍣¯1⊢⍵)≠9:'Não tem 9 dígitos'⋄C←11-11|+/(¯1↓10-⍳9)×(¯1↓10⊥⍣¯1⊢⍵)⋄D←8↓10⊥⍣¯1⊢⍵⋄t←(((C≥10)∧(D=0))∨((C<10)∧(D=C))):'NIF válido'⋄(~t):'NIF inválido'} ⍝ monadic dfn em APL que aceita NIF como input, valida se é numérico, valida se tem 9 dígitos. Se numérico com 9 dígitos, devolve se é válido ou inválido
public static bool Nif(string nifNumber) { int tamanhoNumero = 9; // Tamanho do número NIF string filteredNumber = Regex.Match(nifNumber, @"[0-9]+").Value; // extrair Número if (filteredNumber.Length != tamanhoNumero || int.Parse(filteredNumber[0].ToString()) == 0) { return false; } // Verificar Tamanho, e zero no inicio int calculoCheckSum = 0; // Calcular check sum for (int i = 0; i < tamanhoNumero - 1; i++) { calculoCheckSum += (int.Parse(filteredNumber[i].ToString()))*(tamanhoNumero - i); } int digitoVerificacao = 11-(calculoCheckSum % 11); if (digitoVerificacao > 9) { digitoVerificacao = 0; } // retornar validação return digitoVerificacao == int.Parse(filteredNumber[tamanhoNumero - 1].ToString()); }
Em Itália, o número de contribuinte é calculado com base no nome, ano de nascimento e outros detalhes particulares, de forma a poder ser determinado pelo próprio contribuinte, sem ser necessário esperar pela emissão do documento oficial.
No Brasil, existem os equivalentes ao NIF cadastro de pessoas físicas (CPF), utilizado para indivíduos, e o equivalente ao NIPC cadastro nacional da pessoa jurídica (CNPJ) para empresas. Ambos são atribuídos pela Receita Federal do Brasil.