Hoppa till innehåll
🛠️
Whiz Tools

CNPJ Generator & Validator - Verktyg för brasiliansk företagsidentifikation

Generera giltiga CNPJ-nummer för testning eller validera brasilianska företags-ID direkt. Gratis verktyg med kontrollsiffersverifiering för utvecklare som arbetar med Cadastro Nacional da Pessoa Jurídica.

Brasiliansk CNPJ-generator och validering

CNPJ-generator

Generera ett giltigt brasilianskt CNPJ-nummer för testningsändamål.

CNPJ-validering

Kontrollera om ett brasilianskt CNPJ-nummer är giltigt.

Laddningsberäknare...
📚

Dokumentation

Förstå brasilianska CNPJ-nummer

CNPJ (Cadastro Nacional da Pessoa Jurídica) är Brasiliens version av ett företags skatteidentifikationsnummer—ett 14-siffrigt nummer som identifierar varje juridisk affärsenhet i landet. Om du bygger programvara som hanterar brasilianska affärsdata, kommer du snabbt att stöta på dessa nummer i registreringsformulär, fakturor och API-integreringar.

Här är det som gör detta verktyg praktiskt: det genererar matematiskt giltiga CNPJs för testning utan att använda riktiga företagsidentifierare. När du sätter upp en testdatabas med 1 000 poster eller felsöker en valideringsrutin klockan 2 på natten, behöver du CNPJs som klarar algoritmiska kontroller men inte av misstag matchar faktiska företag. Det är exakt vad detta genererar.

De nummer som skapas här följer den officiella Receita Federal (brasilianska skattemyndighetens) valideringsalgoritm. De har korrekta kontrollsiffror och korrekt formatering—de är bara inte registrerade i myndighetens databas. Tänk på dem som syntaktiskt korrekta testdata som inte skapar efterlevnadsproblem i din utvecklingsmiljö.

Vad är ett CNPJ och varför det är viktigt

Ett CNPJ fungerar som Brasiliens företagsidentifierare—liknande ett EIN i USA eller ett företagsregistreringsnummer i Storbritannien. Varje affärsenhet som verkar lagligt i Brasilien måste ha ett, utfärdat av Receita Federal (Federal Revenue Service).

Du kommer att stöta på CNPJs när:

  • Betalningshantering: Brasilianska betalningsportaler kräver CNPJ-validering för handlarkonton
  • Skatteefterlevnad: Varje faktura som utfärdas i Brasilien måste innehålla ett giltigt CNPJ
  • Företagsregistrering: Statliga myndigheter använder CNPJs för att spåra juridiska enheter över system
  • Bankverksamhet: Öppna företagskonton eller behandla internationella överföringar
  • Import/export: Tullhandlingar kräver CNPJ-verifiering
  • Statliga kontrakt: Offentliga anbudssystem validerar CNPJs innan anbud accepteras

Av min erfarenhet av att arbeta med brasilianska e-handelsplattformar är en av de vanligaste integrationspunkterna utcheckningsflödet där användare anger sitt CNPJ för företagsköp. Din valideringslogik behöver fånga formateringsfel innan betalningsprocessorn gör det—annars kommer du att se misslyckade transaktioner som kunde ha förhindrats.

CNPJ-struktur och format

Ett CNPJ består av 14 siffror formaterat som: XX.XXX.XXX/YYYY-ZZ

Nedbrytning av strukturen:

  1. Första 8 siffrorna (XX.XXX.XXX): Det unika registreringsnumret som tilldelats företaget
  2. Nästa 4 siffror (/YYYY): Filial- eller etableringsidentifierare—/0001 anger huvudkontor, medan /0002, /0003 representerar filialer
  3. Sista 2 siffrorna (-ZZ): Kontrollsiffror beräknade genom en viktad algoritm

Exempel: 12.345.678/0001-95

Det intressanta med filialidentifieraren: när ett företag öppnar flera platser får varje plats samma första 8 siffror men ett annorlunda filialnummer. Så om en detaljhandelskedja har 50 butiker kommer de att ha CNPJ som slutar med /0001 till /0050, alla med samma basnummer. Detta gör det enkelt att identifiera att flera CNPJ tillhör samma moderorganisation.

Kontrollsiffrorna är inte slumpmässiga—de beräknas med en modulus-11-algoritm med specifika viktsekvenser. Detta designval, vanligt i brasilianska administrativa dokument, gör det matematiskt svårt att förfalska giltiga nummer eller oavsiktligt skapa giltiga nummer genom skrivfel.

Hur CNPJ-validering faktiskt fungerar

Valideringsalgoritmen använder en viktad modulus-11-beräkning. Här är logiken bakom den:

Första kontrollsiffrans beräkning

  1. Ta de första 12 siffrorna och multiplicera varje med vikter: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Summera alla produkter
  3. Dividera summan med 11 och få resten
  4. Om resten < 2, är kontrollsiffran 0; annars är den 11 - resten

Andra kontrollsiffrans beräkning

  1. Ta de första 13 siffrorna (inklusive första kontrollsiffran) och multiplicera med vikter: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Summera alla produkter
  3. Dividera med 11 och få resten
  4. Om resten < 2, är kontrollsiffran 0; annars är den 11 - resten

Varför denna metod fungerar: Det viktade multiplikationssystemet skapar ett unikt förhållande mellan alla 12 bassiffror och de resulterande kontrollsiffrorna. Att ändra även en enda siffra i basnumret producerar olika kontrollsiffror, vilket fångar vanliga avskrivningsfel som att byta plats på två siffror (skriva 12.345 istället för 12.354).

En praktisk anmärkning: CNPJs med alla identiska siffror (som 11.111.111/1111-11) är automatiskt ogiltiga, även om de klarar den matematiska kontrollen. Receita Federal utesluter uttryckligen dessa mönster för att förhindra triviala fall.

Hur man använder CNPJ-generatorn och validatorn

Generera test-CNPJs

Behöver du ett giltigt CNPJ för din testdatabas? Så här gör du:

  1. Klicka på "Generera CNPJ"
  2. Verktyget skapar ett matematiskt giltigt nummer direkt
  3. Klicka på "Kopiera" för att lägga det på urklipp
  4. Klistra in det i dina testformulär, databasseeder eller enhetstester

Varje genererat CNPJ klarar alla algoritmiska valideringskontroller men är inte registrerat hos Receita Federal. Det innebär att du kan använda dem fritt i utveckling utan att oroa dig för att råka använda en verklig företagsidentifierare.

Validera CNPJ-nummer

Har du ett CNPJ som du behöver verifiera? Validatorn hanterar det:

  1. Klistra in eller skriv CNPJ:et i inmatningsfältet
  2. Oroa dig inte för formateringen—det fungerar med 12345678000195 eller 12.345.678/0001-95
  3. Klicka på "Validera"
  4. Få omedelbar återkoppling om huruvida kontrollsiffrorna är korrekta

Vad validatorn kontrollerar: rätt längd (14 siffror), korrekta beräkningar av kontrollsiffror och exkludering av ogiltiga mönster som alla samma siffror. Vad den inte kontrollerar: huruvida CNPJ:et är registrerat i statens databas—det kräver direkt förfrågan till Receita Federal.

Verkliga användningsfall för CNPJ-generator och -validator

Mjukvaruutveckling och testning

Databasseeding: När du skapar en testmiljö med realistiska testdata behöver du dussintals eller hundratals giltiga CNPJs. Att manuellt skapa dessa är tidsödande, och användning av riktiga företagsidentifierare väcker integritetsproblem. Genererade CNPJs löser båda problemen.

Enhetstestning av gränsfall: Din valideringsfunktion ska avvisa 00.000.000/0000-00 men acceptera 11.222.333/0001-81. Att ha en generator låter dig snabbt skapa både giltiga och avsiktligt ogiltiga testfall för att verifiera att din logik hanterar gränsbetingelser korrekt.

QA-regressionstest: När man testar registreringsformulär eller B2B-utcheckningsflöden behöver QA-team färska testdata för varje körning. Ett vanligt problem jag sett: testmiljöer förorenas med samma 5-6 CNPJs som används om och om igen, vilket maskerar buggar som bara uppträder med specifika siffermönster.

API-integrationstestning: Om du integrerar med brasilianska betalningsprocessorer som PagSeguro eller Mercado Pago, kräver deras sandlådemiljöer ofta giltig CNPJ-formatering. Matematiken måste vara korrekt även om du inte träffar produktionsdatabaser.

Databehandling och validering

Rensning av importerade data: Du har fått en CSV med 10 000 brasilianska företagsposter. Innan bearbetning behöver du identifiera vilka CNPJs som är felaktiga. Att köra dem genom validatorn flaggar poster med stavfel, trunkering eller felaktiga kontrollsiffror—vilket sparar timmar av nedströms felsökning.

Klientsidans formulärvalidering: Att fånga ogiltiga CNPJs innan formulärinlämning förbättrar användarupplevelsen. Ingen vill fylla i ett 20-fälts registreringsformulär bara för att få ett fel vid inlämningen på grund av att två siffror har förväxlats i deras CNPJ.

Dataanonymisering för analys: När du förbereder produktionsdata för delning med analysgrupper eller externa partners behöver du ersätta riktiga CNPJs med giltiga men falska. Detta upprätthåller referensintegritet i din dataset samtidigt som faktiska företagsidentiteter skyddas.

Internationella affärsverksamheter

Förstå brasilianska krav: Om du expanderar till den brasilianska marknaden kommer du att stöta på CNPJ-krav i kontrakt, fakturor och fraktdokumentation. Att ha ett verktyg för att experimentera med formatet hjälper dig att förstå vad dina system behöver hantera.

Specifikationer för tredjepartsintegration: När du granskar API-dokumentation från brasilianska SaaS-leverantörer ser du ofta CNPJ-fält i nyttolastexempel. Att kunna generera giltiga testvärden hjälper dig att snabbare prototypa integreringar.

Alternativa tillvägagångssätt för CNPJ-validering

Programmeringsbibliotek

Om du behöver CNPJ-validering inbyggt i din applikationslogik implementerar dessa bibliotek algoritmen för kontrollsiffror:

Dessa bibliotek hanterar vanligtvis formatering, parsing och validering för flera brasilianska dokumenttyper (CPF, CNPJ, etc.).

Officiella verifieringsAPI:er

För produktionssystem som behöver verifiera faktisk företagsregistrering:

  • Receita Federal Public Service: Consulta CNPJ API tillåter verifiering mot den officiella databasen (kräver korrekt auktorisering och hastighetsbegränsning)
  • Tredjepartsleverantörer av data: Tjänster som Serasa Experian och Boa Vista SCPC erbjuder kommersiella API:er som returnerar företagsdetaljer, registreringsstatus och kreditinformation

Observera: Dessa tjänster kontrollerar faktisk registrering, inte bara matematisk giltighet. Du behöver korrekt auktorisering och bör räkna med API-kostnader för produktionsanvändning.

När man ska använda respektive tillvägagångssätt

Använd denna webbläsarverktyg när: Du behöver snabb validering utan att installera beroenden, generera testdata för demonstrationer eller lära dig hur CNPJ-validering fungerar.

Använd ett bibliotek när: Du bygger en applikation som behöver klient- eller serversidans validering som en del av formulärbehandlingen.

Använd ett officiellt API när: Du behöver verifiera att ett CNPJ motsvarar en verklig, aktiv affärsenhet med aktuell registreringsstatus.

Tekniska implementeringsdetaljer

Denna verktyg körs helt i din webbläsare med JavaScript—inga serverförfrågningar, ingen data lämnar din maskin. Här är hur algoritmerna fungerar under huven, med kod som du kan anpassa för dina egna projekt:

CNPJ-genereringsalgoritm

1function generateCNPJ() {
2  // Generera de första 12 siffrorna slumpmässigt
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Beräkna första kontrollsiffran
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Beräkna andra kontrollsiffran
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formatera 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

CNPJ-valideringsalgoritm

1function validateCNPJ(cnpj) {
2  // Ta bort icke-numeriska tecken
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Kontrollera om den har rätt längd
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Kontrollera kända ogiltiga mönster (alla samma siffror)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Konvertera till array av siffror
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Kontrollera första verifieringssiffran
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Kontrollera andra verifieringssiffran
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

CNPJ-formateringsfunktion

1function formatCNPJ(cnpj) {
2  // Ta bort icke-numeriska tecken
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formatera baserat på längd
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

Dessa kärnfunktioner kan implementeras i andra programmeringsspråk med samma logik. Här är exempel i Python och Java:

Python-implementation

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    # Generera första 12 siffrorna slumpmässigt
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Beräkna första kontrollsiffran
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Beräkna andra kontrollsiffran
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formatera 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    # Ta bort icke-numeriska tecken
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Kontrollera längd
34    if len(cnpj) != 14:
35        return False
36    
37    # Kontrollera om alla siffror är samma
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Konvertera till lista av heltal
42    digits = [int(d) for d in cnpj]
43    
44    # Validera första kontrollsiffran
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Validera andra kontrollsiffran
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Java-implementation

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        // Generera första 12 siffrorna slumpmässigt
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Beräkna första kontrollsiffran
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Beräkna andra kontrollsiffran
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formatera 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        // Ta bort icke-numeriska tecken
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Kontrollera längd
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Kontrollera om alla siffror är samma
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        // Konvertera till array av heltal
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        // Validera första kontrollsiffran
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Validera andra kontrollsiffran
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Viktiga begränsningar och överväganden

Vad detta verktyg kan och inte kan göra

Vad det validerar: Matematisk korrekthet—huruvida kontrollsiffrorna matchar algoritmens beräkning.

Vad det inte validerar: Huruvida CNPJ är registrerat hos Receita Federal, om det tillhör ett aktivt företag, eller om det är associerat med det företagsnamn du förväntar dig.

Tänk på det som stavningskontroll kontra faktakontroll. Detta verktyg berättar om en CNPJ är "stavad" korrekt enligt matematiska regler, men kan inte avgöra om numret motsvarar en verklig, aktiv affärsenhet.

Juridisk och etisk användning

Genererade CNPJs är endast för testning och utveckling. De är matematiskt giltiga men inte registrerade hos brasilianska myndigheter, vilket innebär:

  • ✅ Säkert att använda för: Befolkning av testdatabaser, enhetstestning av valideringslogik, QA-miljöer, kodexempel i dokumentation
  • ❌ Använd aldrig för: Skattedeklaration, företagsregistrering, kontraktsundertecknande, bearbetning av riktiga transaktioner eller felaktig företagsrepresentation

Att använda en falsk CNPJ för officiella ändamål är inte bara oetiskt—det är olagligt enligt brasiliansk lag och kan resultera i åtal för bedrägeri.

Tekniska begränsningar att känna till

Slumpmässig generering har konsekvenser: Verktyget genererar de första 12 siffrorna slumpmässigt. Riktiga CNPJs som utfärdats av Receita Federal följer interna mönster relaterade till registreringsdatum, regionalt kontor och företagstyp. Genererade nummer kommer inte att matcha dessa mönster, vilket sofistikerade valideringssystem kan flagga.

Ingen semantisk validering: Ett giltigt CNPJ-format innebär inte ett giltigt affärssammanhang. Till exempel har statliga enheter specifika CNPJ-intervall—denna generator kan råka skapa ett, men det skulle inte vara meningsfullt.

Formathantering: Validatorn accepterar olika indataformat (12345678000195, 12.345.678/0001-95), men vissa äldre system förväntar sig exakt formatering. Testa alltid med dina specifika integrationskrav.

Integritet och säkerhet

All bearbetning sker på klientsidan i din webbläsare. Inga CNPJs som du genererar eller validerar skickas till servrar, loggas eller lagras. Verktyget begär, hanterar eller bearbetar ingen personlig information.

Vanliga frågor om CNPJ-validering

Vad är skillnaden mellan att validera och verifiera ett CNPJ?

Validering kontrollerar om numret är matematiskt korrekt—rätt format, korrekta kontrollsiffror, inga ogiltiga mönster. Detta verktyg utför validering.

Verifiering kontrollerar om CNPJ är registrerat hos ett faktiskt företag i Receita Federals databas. Verifiering kräver förfrågan i statens databas och är inte något detta verktyg gör.

Du kan ha ett perfekt giltigt CNPJ som inte är verifierat (som testnumren detta verktyg genererar), eller ett ogiltigt CNPJ som tillhör ett riktigt företag (eftersom någon gjort ett stavfel när det angavs).

Kan jag använda genererade CNPJs för produktionstestning?

Det beror på vad du menar med "produktionstestning." De fungerar bra för staging-miljöer, belastningstestning och pre-launch QA. Men om "produktionstestning" innebär testning med riktiga transaktioner, riktiga statliga API:er eller riktiga finansiella system—då nej, du behöver faktiskt registrerade CNPJs.

Ett säkrare tillvägagångssätt: använd genererade CNPJs i isolerade testmiljöer, och byt sedan till en liten uppsättning riktiga test-företags-CNPJs (som du kontrollerar) när du testar produktionsintegration.

Varför avvisar validatorn 11.111.111/1111-11?

Även om ett CNPJ med identiska siffror matematiskt kan producera giltiga kontrollsiffror, undantar Receita Federal uttryckligen dessa mönster. Det är en affärsregel, inte en matematisk. Detsamma gäller sekventiella mönster i vissa valideringssystem.

Detta liknar hur många system avvisar lösenord som "password123" även om de uppfyller längdkrav—de är tekniskt giltiga men praktiskt oacceptabla.

Hur hanterar jag CNPJ-validering i olika lokaler?

Brasilianska företag som gör internationell affärer utelämnar ibland formateringstecknen när de anger CNPJs i utländska system. Din valideringslogik bör ta bort icke-numeriska tecken innan kontroll:

1const cleanCNPJ = input.replace(/\D/g, ''); // Ta bort allt förutom siffror
2

Acceptera 12.345.678/0001-95, 12345678000195, och 12 345 678 0001 95 som likvärdiga inmatningar.

Vad gäller CNPJ vs CPF-validering?

CPF (Cadastro de Pessoas Físicas) är Brasiliens individuella skatteidentifikation, medan CNPJ är för företag. De använder olika algoritmer för kontrollsiffror och längder (CPF har 11 siffror, CNPJ har 14). Om du bygger en brasiliansk app som hanterar båda, behöver du separata valideringsfunktioner—även om många bibliotek stöder båda formaten.

Ett vanligt mönster: låt användare mata in antingen CPF eller CNPJ i samma fält, och identifiera sedan vilken typ baserat på längd efter att ha tagit bort formateringstecken.

Fungerar detta för utländska företag som verkar i Brasilien?

Utländska företag som verkar i Brasilien måste också erhålla CNPJs från Receita Federal. Deras CNPJs följer samma format och valideringsregler som inhemska företag. Det finns inget särskilt "utländskt företag" CNPJ-format.

Dock kan utländska företag ha ytterligare dokumentationskrav och olika registreringsprocesser—konsultera en brasiliansk affärsjurist för specifika detaljer.

Kan jag fråga statens databas för att verifiera CNPJ-registrering?

Ja, Receita Federal tillhandahåller offentlig åtkomst för att verifiera grundläggande CNPJ-information genom deras Consulta Pública CNPJ tjänst. Du kan manuellt slå upp CNPJs eller, med rätt auktorisation, använda deras API:er för programmatisk åtkomst.

Observera att omfattande användning kräver registrering och det finns hastighetsgränser för att förhindra missbruk.

Hur ofta ändras CNPJs?

CNPJs är permanenta identifierare som inte ändras när ett företag byter namn, adress eller ägarstruktur. Men om ett företag stängs och senare återregistreras kan det få ett nytt CNPJ. Filialsnummer (den /XXXX delen) kan läggas till när företag öppnar nya platser, men det grundläggande 8-siffriga numret förblir konstant.

Referenser och ytterligare resurser

Officiella statliga källor

  1. Receita Federal do Brasil - Officiell Portal - Den brasilianska federala skattemyndighetens officiella webbplats med CNPJ-registrerings- och verifieringstjänster
  2. Consulta Pública CNPJ - Offentlig CNPJ-sökning - Officiell statlig tjänst för att verifiera CNPJ-registreringsstatus
  3. Normativ instruktion RFB nr 1863/2018 - Rättsliga föreskrifter som styr CNPJ-registrering och användning i Brasilien

Tekniska standarder och dokumentation

  1. Modulär aritmetiska algoritmer - Beräkningen av kontrollsiffran använder modulo 11-aritmetik, ett standardtillvägagångssätt för valideringssiffer
  2. ISO/IEC 7064 - Internationell standard för kontrollsiffersystem som påverkade den brasilianska dokumentvalidesignen
  3. Brasilianska civillagen (Lag nr 10.406/2002) - Rättslig ram som definierar affärsenheternas klassificeringar som kräver CNPJ-registrering

Utvecklarresurser

  1. NPM-paketregister - npmjs.com - Förråd för JavaScript-bibliotek inklusive brasilianska dokumentvalidatorer
  2. PyPI (Python Package Index) - pypi.org - Python-bibliotek för CNPJ-validering och brasiliansk dokumentbehandling
  3. GitHub - Öppen källkods-implementationer av CNPJ-validering i flera programmeringsspråk

Börja generera och validera CNPJs

Oavsett om du bygger en brasiliansk e-handelsplattform, testar betalningsintegreringar med Mercado Pago eller bara behöver förstå hur CNPJ-validering fungerar, ger det här verktyget dig omedelbar tillgång till både genererings- och valideringsmöjligheter.

Ingen installation, inga API-nycklar, ingen komplicerad inställning. Öppna bara din webbläsare och börja arbeta med giltiga brasilianska företagsidentifierare.