Loading AI tools
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 compartilhar 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]:
- 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.
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 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.
- 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.º.
- O algoritmo em Go foi retirado do package nifptvalidator
- No GitHub: artdpix/ptnifvalidation
Wikiwand in your browser!
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
