Número de identificação fiscal

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).

Definição

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."

NIF das Empresas

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).

NIF e Senha das Finanças em Portugal

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 compartilhar tais informações.

Constituição e interpretação

É 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]:

1 a 3: Pessoa singular, a gama 3 começou a ser atribuída em junho de 2019;^[2]
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;^[3]
5: Pessoa colectiva obrigada a registo no Registo Nacional de Pessoas Colectivas;^[4]
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.

Obter dígito de controlo

O NIF tem 9 dígitos, sendo o último o digito de controlo. Para ser calculado o digito de controlo:

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;
Some os resultados;
Calcule o resto da divisão do número por 11;
Se o resto for 0 (zero) ou 1 (um) o dígito de controlo será 0 (zero);
Se for outro qualquer algarismo X, o dígito de controlo será o resultado da subtracção 11 - X.

Exemplo de cálculo do dígito de controlo em Python

import doctest

def 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()

Exemplo de validação em Python

import doctest

def 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()

Exemplo de validação em JavaScript

  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]);
  }

Exemplo de validação em PHP

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;
}

Exemplo de validação em R

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
}

Exemplo de validação em Rust^[5]

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;
}

Exemplo de validação em Ruby (version 2.4+)

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

Exemplo de validação em Go ^[6]

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
}

Exemplo de validação em TypeScript

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]);
  }
}

Exemplo de validação em Java^[7]

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';
}

Exemplo de validação em APL

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

Exemplo de validação em C#^[8]

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 outros países

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.

Referências

↑ Instruções administrativas disponíveis no Portal das Finanças Arquivado em 17 de agosto de 2016, no Wayback Machine..
↑ «Atribuição de Nova Gama de NIF a Pessoas Singulares.». info.portaldasfinancas.gov.pt. Consultado em 7 de agosto de 2019
↑ PORTUGAL Decreto-lei n.º 14/2013, de 28 de janeiro, artigo 4.º.
↑ PORTUGAL Decreto-lei 14/2013, de 28 de janeiro, n.º 1 do artigo 11.º.
↑ No GitHub: https://github.com/halufa/nif-validator-pt
↑ O algoritmo em Go foi retirado do package nifptvalidator
↑ No GitHub: VatNumber
↑ No GitHub: artdpix/ptnifvalidation

Este artigo sobre economia é um esboço. Você pode ajudar a Wikipédia expandindo-o.

[1] Instruções administrativas disponíveis no Portal das Finanças Arquivado em 17 de agosto de 2016, no Wayback Machine..

[2] «Atribuição de Nova Gama de NIF a Pessoas Singulares.». info.portaldasfinancas.gov.pt. Consultado em 7 de agosto de 2019

[:0-3] PORTUGAL Decreto-lei n.º 14/2013, de 28 de janeiro, artigo 4.º.

[4] PORTUGAL Decreto-lei 14/2013, de 28 de janeiro, n.º 1 do artigo 11.º.

[5] No GitHub: https://github.com/halufa/nif-validator-pt

[6] O algoritmo em Go foi retirado do package nifptvalidator

[7] No GitHub: VatNumber

[8] No GitHub: artdpix/ptnifvalidation

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]