Número de identificação fiscal

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 em suas relações fiscais. No entanto, é crucial ter cuidado ao lidar com o "password das Finanças" associado ao NIF. Tem sido relatado um esquema fraudulento onde certos profissionais, incluindo alguns advogados, retêm esta password, limitando assim o acesso direto do cidadão às suas próprias questões fiscais. Esta prática pode não só levar a problemas na relação entre o profissional e o cliente, mas também a potenciais fraudes fiscais. Portanto, é recomendado que os cidadãos mantenham o controle direto sobre suas credenciais fiscais e sejam cautelosos ao compartilhar tais informações.^[1][2]

É 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^[3]:

• 1 a 3: Pessoa singular, a gama 3 começou a ser atribuída em junho de 2019;^[4]
• 45: Pessoa singular. Os algarismos iniciais "45" correspondem aos cidadãos não residentes que apenas obtenham em território português rendimentos sujeitos a retenção na fonte a título definitivo;^[5]
• 5: Pessoa colectiva obrigada a registo no Registo Nacional de Pessoas Colectivas;^[6]
• 6: Organismo da Administração Pública Central, Regional ou Local;
• 70, 74 e 75: Herança Indivisa, em que o autor da sucessão não era empresário individual, ou Herança Indivisa em que o cônjuge sobrevivo tem rendimentos comerciais;
• 71: Não residentes colectivos sujeitos a retenção na fonte a título definitivo;
• 72: Fundos de investimento;
• 77: Atribuição Oficiosa de NIF de sujeito passivo (entidades que não requerem NIF junto do RNPC);
• 78: Atribuição oficiosa a não residentes abrangidos pelo processo VAT REFUND;
• 79: Regime excepcional - Expo 98;
• 8: "empresário em nome individual" (actualmente obsoleto, já não é utilizado nem é válido);
• 90 e 91: Condomínios, Sociedade Irregulares, Heranças Indivisas cujo autor da sucessão era empresário individual;
• 98: Não residentes sem estabelecimento estável;
• 99: Sociedades civis sem personalidade jurídica.

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:

1. Multiplique o 8.º dígito por 2, o 7.º dígito por 3, o 6.º dígito por 4, o 5.º dígito por 5, o 4.º dígito por 6, o 3.º dígito por 7, o 2.º dígito por 8 e o 1.º dígito por 9;
2. Some os resultados;
3. Calcule o resto da divisão do número por 11;
4. Se o resto for 0 (zero) ou 1 (um) o dígito de controlo será 0 (zero);
5. Se for outro qualquer algarismo X, o dígito de controlo será o resultado da subtracção 11 - X.

import doctestdef check_digit(string_num):    """ Calcula o digito de controle de um NIF Ex. 99999999[0]    >>> check_digit('99999999')     '0'    >>> check_digit('74089837')     '9'    >>> check_digit('28702400')     '8'    """    if not string_num.isdigit(): raise ValueError    soma = sum([int(digito) * (9 - pos) for pos, digito in enumerate(string_num)])    resto = soma % 11    if resto == 0: return '0'    if resto == 1: return '0'    return str(11 - resto)if __name__ == '__main__':     doctest.testmod()

import doctestdef valida_nif(numero):    """ Validação do número de identificação fiscal    >>> valida_nif('999999990')     True    >>> valida_nif('999999999')     False    >>> valida_nif('501442600')     True    """    EXPECTED_DIGITS = 9    if not numero.isdigit() or len(numero) != EXPECTED_DIGITS:         return False    return numero[-1] == check_digit(numero[0:8])if __name__ == '__main__':     doctest.testmod()

  function validateNIF(value) {    const nif = typeof value === 'string' ? value : value.toString();    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.substr(0, 1)) && !validationSets.two.includes(nif.substr(0, 2))) return false;    const total = nif[0] * 9 + nif[1] * 8 + nif[2] * 7 + nif[3] * 6 + nif[4] * 5 + nif[5] * 4 + nif[6] * 3 + nif[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 lengthif len(nif) != 9 {return false}// check if all characters are numbersfor _, char := range nif {if char < '0' || char > '9' {return false}}// validate prefixesif !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-digitsum := 0for i, char := range nif[:8] {v, err := strconv.Atoi(string(char))if err != nil {return false}sum += v * (9 - i)}rmd := sum % 11ckd := 0switch rmd {case 0, 1:ckd = 0default:ckd = 11 - rmd}// compare the provided check digit with the calculated onecompare, err := strconv.Atoi(string(nif[8]))if err != nil {return false}return compare == ckd}

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.substr(0, 1)) && !validationSets.two.includes(nif.substr(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 numbersif (!number.matches("[0-9]+") || number.length()!=max) return false;int checkSum=0;//calculate checkSumfor (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 zeroif (checkDigit>9) checkDigit=0;//compare checkDigit with the last number of NIFreturn 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 que pode ser determinado pelo próprio contribuinte, sem ser necessário esperar a 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.