Salta al contingut
🛠️
Whiz Tools

Generador i Validador de CNPJ - Eina d'Identificació Empresarial Brasilera

Genera números de CNPJ vàlids per a proves o valida identificadors empresarials brasilers a l'instant. Eina gratuïta amb verificació de dígit de control per a desenvolupadors que treballen amb el Cadastre Nacional de Persones Jurídiques.

Generador i Validador de CNPJ Brasiler

Generador de CNPJ

Genera un número de CNPJ brasiler vàlid per a proves.

Validador de CNPJ

Comprova si un número de CNPJ brasiler és vàlid.

Calculadora de càrrega...
📚

Documentació

Entenent els Números CNPJ Brasilers

El CNPJ (Cadastre Nacional de la Persona Jurídica) és la versió brasilera d'un identificador fiscal corporatiu: un número de 14 dígits que identifica cada entitat empresarial legal al país. Si estàs construint programari que gestiona dades empresarials brasileres, aviat et trobaràs amb aquests números en formularis de registre, factures i integracions d'API.

Heus aquí el que fa que aquesta eina sigui pràctica: genera CNPJs matemàticament vàlids per a proves sense fer servir identificadors d'empreses reals. Quan estàs configurant una base de dades de proves amb 1.000 registres o depurant una rutina de validació a les 2 de la matinada, necessites CNPJs que passin controls algorítmics però que no coincideixin accidentalment amb empreses reals. Això és exactament el que genera.

Els números creats aquí segueixen l'algoritme de validació oficial de la Receita Federal (Servei de Rendiment Federal Brasiler). Tenen dígits de verificació correctes i un format adequat: simplement no estan registrats a la base de dades governamental. Penseu-los com a dades de proves sintàcticament correctes que no crearan problemes de compliment al vostre entorn de desenvolupament.

Què és un CNPJ i per què és important

Un CNPJ serveix com a identificador corporatiu del Brasil, similar a un EIN als Estats Units o un Número de Registre d'Empresa al Regne Unit. Cada entitat empresarial que operi legalment al Brasil ha de tenir-ne un, emès per la Receita Federal (Servei de Rendatges Federal).

Trobaràs CNPJs quan:

  • Processament de pagaments: Les passarel·les de pagament brasileres requereixen validació de CNPJ per a comptes de comerciants
  • Compliment fiscal: Cada factura emesa al Brasil ha d'incloure un CNPJ vàlid
  • Registre empresarial: Les agències governamentals utilitzen CNPJs per fer un seguiment d'entitats legals a través de sistemes
  • Operacions bancàries: Obertura de comptes corporatius o processament de transferències internacionals
  • Importació/exportació: La documentació duanera requereix verificació de CNPJ
  • Contractes governamentals: Els sistemes de licitació pública validen CNPJs abans d'acceptar ofertes

En la meva experiència treballant amb plataformes de comerç electrònic brasileres, un dels punts d'integració més comuns és el flux de pagament on els usuaris introdueixen el seu CNPJ per a compres corporatives. La vostra lògica de validació ha de detectar errors de format abans que ho faci el processador de pagaments, d'altra manera veureu transaccions fallides que s'haurien pogut prevenir.

Estructura i Format del CNPJ

Un CNPJ consta de 14 dígits formatats com: XX.XXX.XXX/YYYY-ZZ

Desglossant l'estructura:

  1. Primers 8 dígits (XX.XXX.XXX): El número de registre base assignat únicament a l'empresa
  2. Següents 4 dígits (/YYYY): Identificador de sucursal o establiment—/0001 indica seu central, mentre que /0002, /0003 representen ubicacions de sucursals
  3. Últims 2 dígits (-ZZ): Dígits de verificació calculats mitjançant un algoritme ponderat

Exemple: 12.345.678/0001-95

Què és interessant sobre l'identificador de sucursal: quan una empresa obre múltiples ubicacions, cada una rep els mateixos primers 8 dígits però un número de sucursal diferent. Així, si una cadena de comerç té 50 botigues, tindran CNPJs que acaben en /0001 fins /0050, tots compartint el mateix número base. Això facilita identificar que múltiples CNPJs pertanyen a la mateixa organització principal.

Els dígits de verificació no són aleatoris—es calculen mitjançant un algoritme de mòdul-11 amb seqüències de pesos específiques. Aquesta elecció de disseny, comuna en documents administratius brasilers, fa matemàticament difícil forjar números vàlids o crear-ne accidentalment de vàlids a través d'errors tipogràfics.

Com funciona realment la validació de CNPJ

L'algoritme de validació utilitza un càlcul de mòdul-11 ponderat. Aquí és la lògica darrere d'això:

Càlcul del primer dígit de verificació

  1. Agafeu els primers 12 dígits i multipliqueu cada un pels pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Sumeu tots els productes
  3. Dividiu la suma per 11 i obteniu el residu
  4. Si el residu < 2, el dígit de verificació és 0; en cas contrari, és 11 - residu

Càlcul del segon dígit de verificació

  1. Agafeu els primers 13 dígits (incloent el primer dígit de verificació) i multipliqueu pels pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Sumeu tots els productes
  3. Dividiu per 11 i obteniu el residu
  4. Si el residu < 2, el dígit de verificació és 0; en cas contrari, és 11 - residu

Per què aquest enfocament funciona: El sistema de multiplicació ponderat crea una relació única entre tots els 12 dígits base i els dígits de verificació resultants. Canviar fins i tot un sol dígit al número base produeix dígits de verificació diferents, la qual cosa detecta errors comuns de transcripció com ara intercanviar dos dígits (escriure 12.345 en lloc de 12.354).

Una nota pràctica: Els CNPJs amb tots els dígits idèntics (com 11.111.111/1111-11) són automàticament invàlids, fins i tot si passen la comprovació matemàtica. La Receita Federal exclou explícitament aquests patrons per prevenir casos trivials.

Com Usar el Generador i Validador de CNPJ

Generació de CNPJs de Prova

Necessites un CNPJ vàlid per a la teva base de dades de proves? Aquí tens com fer-ho:

  1. Fes clic a "Generar CNPJ"
  2. L'eina crea un número matemàticament vàlid instantàniament
  3. Fes clic a "Copiar" per agafar-lo al teu portapapers
  4. Enganxa'l als teus formularis de proves, llavors de base de dades o proves unitàries

Cada CNPJ generat passa tots els controls de validació algorítmica però no està registrat a la Receita Federal. Això significa que pots usar-los lliurement en el desenvolupament sense preocupar-te d'usar accidentalment l'identificador d'una empresa real.

Validació de Números CNPJ

Tens un CNPJ que necessites verificar? El validador ho gestiona:

  1. Enganxa o escriu el CNPJ al camp d'entrada
  2. No et preocupis per el format—funciona amb 12345678000195 o 12.345.678/0001-95
  3. Fes clic a "Validar"
  4. Obté retroalimentació instantània sobre si els dígits de control són correctes

Què comprova el validador: longitud adequada (14 dígits), càlculs correctes de dígits de control i exclusió de patrons invàlids com dígits iguals. Què no comprova: si el CNPJ està registrat a la base de dades governamental—això requereix consultar directament la Receita Federal.

Casos d'ús reals del Generador i Validador de CNPJ

Desenvolupament de programari i proves

Sembrat de bases de dades: Quan es configura un entorn d'etapa amb dades de proves realistes, es necessiten desenes o centenars de CNPJs vàlids. Crear-los manualment és tediós, i l'ús d'identificadors d'empreses reals planteja problemes de privacitat. Els CNPJs generats resolen ambdós problemes.

Proves d'unitat de casos límit: La seva funció de validació ha de rebutjar 00.000.000/0000-00 però acceptar 11.222.333/0001-81. Tenir un generador permet crear ràpidament casos de proves vàlids i intencionadament invàlids per verificar que la seva lògica gestiona correctament les condicions límit.

Proves de regressió de QA: En provar formularis de registre o fluxos de pagament B2B, els equips de QA necessiten dades de proves fresques per a cada execució. Un problema comú que he vist: els entorns de proves es contaminen amb els mateixos 5-6 CNPJs usats repetidament, la qual cosa emmascara errors que només apareixen amb patrons de dígits específics.

Proves d'integració d'API: Si s'integra amb processadors de pagaments brasilers com PagSeguro o Mercado Pago, els seus entorns de proves sovint requereixen un format de CNPJ vàlid. Les matemàtiques han de ser correctes, encara que no s'estiguin tocant bases de dades de producció.

Processament i validació de dades

Neteja de dades importades: Ha rebut un CSV amb 10.000 registres d'empreses brasileres. Abans de processar, necessita identificar quins CNPJs estan malmesos. Executar-los a través del validador marca les entrades amb errors tipogràfics, truncament o dígits de verificació incorrectes, estalviant hores de depuració posterior.

Validació de formularis del costat del client: Detectar CNPJs invàlids abans de l'enviament del formulari millora l'experiència d'usuari. Ningú vol omplir un formulari de registre de 20 camps per obtenir un error en l'enviament perquè ha transposat dos dígits al seu CNPJ.

Anonimització de dades per a anàlisi: En preparar dades de producció per compartir amb equips d'anàlisi o socis externs, cal substituir els CNPJs reals per uns de vàlids però ficticis. Això manté la integritat referencial al conjunt de dades mentre es protegeix la identitat real de les empreses.

Operacions comercials internacionals

Comprensió dels requisits brasilers: Si s'expandeix al mercat brasiler, es trobarà amb requisits de CNPJ en contractes, factures i documentació d'enviament. Tenir una eina per experimentar amb el format ajuda a entendre el que els seus sistemes necessiten gestionar.

Especificacions d'integració de tercers: En revisar la documentació d'API de proveïdors brasilers de SaaS, sovint es veuran camps de CNPJ en exemples de càrrega útil. Poder generar valors de proves vàlids ajuda a prototipar integracions més ràpidament.

Mètodes Alternatius de Validació de CNPJ

Biblioteques de Programació

Si necessiteu la validació de CNPJ integrada en la lògica de la vostra aplicació, aquestes biblioteques implementen l'algoritme de dígit de verificació:

Aquestes biblioteques normalment gestionen el format, l'anàlisi i la validació de diversos tipus de documents brasilers (CPF, CNPJ, etc.).

APIs de Verificació Oficial

Per a sistemes de producció que necessiten verificar el registre empresarial real:

  • Servei Públic de Receita Federal: L'API de Consulta CNPJ permet la verificació davant la base de dades oficial (requereix autorització adequada i limitació de taxa)
  • Proveïdors de dades de tercers: Serveis com Serasa Experian i Boa Vista SCPC ofereixen APIs comercials que retornen detalls de l'empresa, estat de registre i informació de crèdit

Nota: Aquests serveis comproven el registre real, no només la validesa matemàtica. Necessitareu una autorització adequada i cal esperar costos d'API per a ús en producció.

Quan Usar Cada Enfocament

Useu aquesta eina de navegador quan: Necessiteu una validació ràpida sense instal·lar dependències, generar dades de proves per a demostracions o aprendre com funciona la validació de CNPJ.

Useu una biblioteca quan: Esteu construint una aplicació que necessita validació al costat del client o del servidor com a part del processament de formularis.

Useu una API oficial quan: Necessiteu verificar que un CNPJ correspon a una entitat empresarial real i activa amb l'estat de registre actual.

Detalls Tècnics d'Implementació

Aquesta eina funciona completament al navegador mitjançant JavaScript, sense sol·licituds de servidor ni dades que surtin de la seva màquina. Aquí és com funcionen els algorismes sota el capó, amb codi que pot adaptar per als seus propis projectes:

Algorisme de Generació de CNPJ

1function generateCNPJ() {
2  // Generar els primers 12 dígits de manera aleatòria
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Calcular el primer dígit de verificació
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Calcular el segon dígit de verificació
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formatar el CNPJ
14  return formatCNPJ(digits.join(''));
15}
16
17function calculateCheckDigit(digits) {
18  const weights = digits.length < 13 
19    ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] 
20    : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
21  
22  const sum = digits.reduce((acc, digit, index) => {
23    return acc + digit * weights[index];
24  }, 0);
25  
26  const remainder = sum % 11;
27  return remainder < 2 ? 0 : 11 - remainder;
28}
29

Algorisme de Validació de CNPJ

1function validateCNPJ(cnpj) {
2  // Eliminar caràcters no numèrics
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Comprovar si té la longitud correcta
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Comprovar patrons invàlids coneguts (tots els mateixos dígits)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Convertir a matriu de dígits
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Comprovar el primer dígit de verificació
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Comprovar el segon dígit de verificació
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

Funció de Formatació de CNPJ

1function formatCNPJ(cnpj) {
2  // Eliminar caràcters no numèrics
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formatar en funció de la longitud
6  if (cleanCNPJ.length <= 2) {
7    return cleanCNPJ;
8  } else if (cleanCNPJ.length <= 5) {
9    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2)}`;
10  } else if (cleanCNPJ.length <= 8) {
11    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5)}`;
12  } else if (cleanCNPJ.length <= 12) {
13    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8)}`;
14  } else {
15    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8, 12)}-${cleanCNPJ.slice(12, 14)}`;
16  }
17}
18

Aquestes funcions principals es poden implementar en altres llenguatges de programació seguint la mateixa lògica. Aquí hi ha exemples en Python i Java:

Implementació en Python

1import random
2
3def calculate_check_digit(digits):
4    weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] if len(digits) < 13 else [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
5    
6    total = 0
7    for i in range(len(digits)):
8        total += digits[i] * weights[i]
9    
10    remainder = total % 11
11    return 0 if remainder < 2 else 11 - remainder
12
13def generate_cnpj():
14    # Generar els primers 12 dígits de manera aleatòria
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Calcular el primer dígit de verificació
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Calcular el segon dígit de verificació
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formatar el CNPJ
26    cnpj = ''.join(map(str, digits))
27    return f"{cnpj[:2]}.{cnpj[2:5]}.{cnpj[5:8]}/{cnpj[8:12]}-{cnpj[12:]}"
28
29def validate_cnpj(cnpj):
30    # Eliminar caràcters no numèrics
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Comprovar longitud
34    if len(cnpj) != 14:
35        return False
36    
37    # Comprovar si tots els dígits són iguals
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Convertir a llista d'enters
42    digits = [int(d) for d in cnpj]
43    
44    # Validar el primer dígit de verificació
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Validar el segon dígit de verificació
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Implementació en Java

1import java.util.Random;
2
3public class CNPJUtils {
4    
5    public static String generateCNPJ() {
6        Random random = new Random();
7        int[] digits = new int[14];
8        
9        // Generar els primers 12 dígits de manera aleatòria
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Calcular el primer dígit de verificació
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Calcular el segon dígit de verificació
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formatar el CNPJ
21        return String.format("%02d.%03d.%03d/%04d-%02d",
22                digits[0] * 10 + digits[1],
23                digits[2] * 100 + digits[3] * 10 + digits[4],
24                digits[5] * 100 + digits[6] * 10 + digits[7],
25                digits[8] * 1000 + digits[9] * 100 + digits[10] * 10 + digits[11],
26                digits[12] * 10 + digits[13]);
27    }
28    
29    private static int calculateCheckDigit(int[] digits, int length) {
30        int[] weights = length < 13 
31            ? new int[]{5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
32            : new int[]{6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
33        
34        int sum = 0;
35        for (int i = 0; i < length; i++) {
36            sum += digits[i] * weights[i];
37        }
38        
39        int remainder = sum % 11;
40        return remainder < 2 ? 0 : 11 - remainder;
41    }
42    
43    public static boolean validateCNPJ(String cnpj) {
44        // Eliminar caràcters no numèrics
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Comprovar longitud
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Comprovar si tots els dígits són iguals
53        boolean allDigitsSame = true;
54        for (int i = 1; i < cnpj.length(); i++) {
55            if (cnpj.charAt(i) != cnpj.charAt(0)) {
56                allDigitsSame = false;
57                break;
58            }
59        }
60        if (allDigitsSame) {
61            return false;
62        }
63        
64        // Convertir a matriu d'enters
65        int[] digits = new int[14];
66        for (int i = 0; i < 14; i++) {
67            digits[i] = Character.getNumericValue(cnpj.charAt(i));
68        }
69        
70        // Validar el primer dígit de verificació
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Validar el segon dígit de verificació
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Limitacions i Consideracions Importants

Què Pot i No Pot Fer Aquesta Eina

Què valida: Correcció matemàtica—si els dígits de verificació coincideixen amb el càlcul de l'algoritme.

Què no valida: Si el CNPJ està registrat a la Receita Federal, si pertany a una empresa activa, o si està associat amb el nom de negoci que s'espera.

Penseu-ho com la correcció ortogràfica versus la verificació de fets. Aquesta eina us diu si un CNPJ està "escrit" correctament d'acord amb les regles matemàtiques, però no pot dir-vos si el número correspon a una entitat empresarial real i activa.

Ús Legal i Ètic

Els CNPJ generats són només per a proves i desenvolupament. Són matemàticament vàlids però no estan registrats amb les autoritats brasileres, la qual cosa significa:

  • ✅ Segur per a: Omplir bases de dades de proves, proves unitàries de lògica de validació, entorns de QA, exemples de codi en documentació
  • ❌ Mai usar per a: Presentació d'impostos, registre d'empreses, signatura de contractes, processament de transaccions reals, o representació falsa de la identitat empresarial

Usar un CNPJ fals per a propòsits oficials no només és poc ètic—és il·legal sota la llei brasilera i pot resultar en càrrecs de frau.

Limitacions Tècniques a Conèixer

La generació aleatòria té implicacions: L'eina genera els primers 12 dígits de manera aleatòria. Els CNPJ reals emesos per la Receita Federal segueixen patrons interns relacionats amb la data de registre, oficina regional i tipus d'empresa. Els números generats no coincidiran amb aquests patrons, la qual cosa els sistemes de validació sofisticats podrien marcar.

Cap validació semàntica: Un format de CNPJ vàlid no significa context empresarial vàlid. Per exemple, les entitats governamentals tenen rangs de CNPJ específics—aquest generador podria crear-ne un per casualitat, però no seria significatiu.

Gestió de format: El validador accepta diversos formats d'entrada (12345678000195, 12.345.678/0001-95), però alguns sistemes antics esperen un format exacte. Sempre proveu amb els requisits específics de la vostra integració.

Privadesa i Seguretat

Tot el processament es realitza al costat del client al vostre navegador. Cap CNPJ que genereu o valideu s'envia a servidors, es registra o s'emmagatzema. L'eina no sol·licita, gestiona o processa cap informació personal.

Preguntes Freqüents sobre la Validació de CNPJ

Quina és la diferència entre validar i verificar un CNPJ?

Validació comprova si el número és matemàticament correcte: format adequat, dígits de control correctes, sense patrons invàlids. Aquesta eina fa validació.

Verificació comprova si el CNPJ està registrat amb una empresa real a la base de dades de la Receita Federal. La verificació requereix consultar la base de dades governamental i no és quelcom que faci aquesta eina.

Pots tenir un CNPJ perfectament vàlid que no estigui verificat (com els números de prova que genera aquesta eina), o un CNPJ invàlid que pertanyi a una empresa real (perquè algú va escriure malament quan l'estava introduint).

Puc usar CNPJs generats per proves de producció?

Depèn del que entenguis per "proves de producció". Són adequats per entorns d'staging, proves de càrrega i QA previ al llançament. Però si per "proves de producció" entens proves amb transaccions reals, API governamentals reals o sistemes financers reals, llavors no, necessitaràs CNPJs registrats realment.

Un enfocament més segur: usa CNPJs generats en entorns de proves aïllats, després canvia a un petit conjunt de CNPJs de proves d'empreses reals (que tu controlis) quan provis integracions de producció.

Per què el validador rebutja 11.111.111/1111-11?

Encara que un CNPJ amb tots els dígits idèntics pot produir matemàticament dígits de control vàlids, la Receita Federal exclou explícitament aquests patrons. És una regla de negoci, no matemàtica. El mateix s'aplica a patrons seqüencials en alguns sistemes de validació.

Això és similar a com molts sistemes rebutgen contrasenyes com "password123" tot i complir els requisits de longitud: tècnicament són vàlides però pràcticament inacceptables.

Com gestiono la validació de CNPJ en diferents localitzacions?

Les empreses brasileres que fan negocis internacionals a vegades eliminen els caràcters de format quan introdueixen CNPJs en sistemes estrangers. La teva lògica de validació hauria de treure els caràcters no numèrics abans de comprovar:

1const cleanCNPJ = input.replace(/\D/g, ''); // Elimina tot excepte dígits
2

Accepta 12.345.678/0001-95, 12345678000195 i 12 345 678 0001 95 com a entrades equivalents.

Quant a la validació de CNPJ vs CPF?

CPF (Cadastro de Pessoas Físicas) és l'identificador fiscal individual del Brasil, mentre que CNPJ és per a empreses. Utilitzen algoritmes de dígits de control i longituds diferents (CPF té 11 dígits, CNPJ té 14). Si estàs construint una aplicació brasilera que gestiona tots dos, necessitaràs funcions de validació separades, tot i que moltes biblioteques suporten tots dos formats.

Un patró comú: permet als usuaris introduir CPF o CNPJ al mateix camp, després detecta quin tipus és basant-se en la longitud després de treure els caràcters de format.

Funciona per a empreses estrangeres que operen al Brasil?

Les empreses estrangeres que operen al Brasil també han d'obtenir CNPJs de la Receita Federal. Els seus CNPJs segueixen el mateix format i regles de validació que les empreses domèstiques. No hi ha un format de CNPJ especial per a "empreses estrangeres".

Tanmateix, les empreses estrangeres podrien tenir requisits de documentació addicionals i processos de registre diferents: consulteu un advocat empresarial brasiler per a detalls específics.

Puc consultar la base de dades governamental per verificar el registre de CNPJ?

Sí, la Receita Federal proporciona accés públic per verificar informació bàsica de CNPJ a través del seu servei Consulta Pública CNPJ. Pots cercar CNPJs manualment o, amb l'autorització adequada, usar les seves API per a accés programàtic.

Nota que l'ús intensiu requereix registre i hi ha límits de taxa per prevenir abusos.

Amb quina freqüència canvien els CNPJs?

Els CNPJs són identificadors permanents que no canvien quan una empresa canvia de nom, adreça o estructura de propietat. Tanmateix, si una empresa tanca i més tard es torna a registrar, pot rebre un nou CNPJ. Els números de sucursal (la part /XXXX) es poden afegir quan les empreses obren nous locals, però el número base de 8 dígits roman constant.

Referents i Recursos Addicionals

Fonts Oficials del Govern

  1. Receita Federal do Brasil - Portal Oficial - El lloc web oficial del Servei de Recaptació Federal del Brasil amb serveis de registre i verificació de CNPJ
  2. Consulta Pública CNPJ - Cerca Pública de CNPJ - Servei oficial del govern per verificar l'estat de registre de CNPJ
  3. Instrucció Normativa RFB Núm. 1863/2018 - Regulacions legals que regeixen el registre i ús de CNPJ al Brasil

Estàndards Tècnics i Documentació

  1. Algorismes d'aritmètica modular - El càlcul del dígit de verificació utilitza aritmètica de mòdul 11, un enfocament estàndard per a dígits de validació
  2. ISO/IEC 7064 - Estàndard internacional per a sistemes de dígits de verificació que va influir en el disseny de validació de documents brasilers
  3. Codi Civil Brasiler (Llei Núm. 10.406/2002) - Marc legal que defineix les classificacions d'entitats empresarials que requereixen registre de CNPJ

Recursos per a Desenvolupadors

  1. Registre de paquets NPM - npmjs.com - Repositori de biblioteques JavaScript, incloent validadors de documents brasilers
  2. PyPI (Índex de Paquets Python) - pypi.org - Biblioteques Python per a validació de CNPJ i processament de documents brasilers
  3. GitHub - Implementacions de codi obert de validació de CNPJ en múltiples llenguatges de programació

Comença a Generar i Validar CNPJs

Tant si estàs construint una plataforma de comerç electrònic brasilera, provant integracions de pagament amb Mercado Pago, o simplement necessites entendre com funciona la validació de CNPJ, aquesta eina et proporciona accés immediat a capacitats de generació i validació.

Sense instal·lació, sense claus API, sense configuració complicada. Simplement obre el teu navegador i comença a treballar amb identificadors empresarials brasilers vàlids.