Open Badge baking förklarat: så lever JSON inuti PNG-filen

En ”bakad” Open Badge är en PNG med assertion-JSON inbäddad som bildmetadata. Märkesfilen ÄR meriten. Så fungerar baking och så verifierar du ett bakat märke.

Nacho Coll Av Uppdaterad 11 min läsning
En ”bakad” Open Badge är en PNG med assertion-JSON inbäddad som bildmetadata. Märkesfilen ÄR meriten. Så fungerar baking och så verifierar du ett bakat märke.

Ladda ner en Open Badge från nästan vilken utfärdare som helst och du får en helt vanlig PNG. Släng in den i en chatt, bifoga den i ett mejl, skriv ut den. Den ser ut som vilken bild som helst. Men filen bär på ett andra, osynligt lager: själva meriten, skriven i bilden som metadata. Det är vad Open Badges-communityn kallar ett bakat märke (baked badge), och det är därför ett märke kan färdas som en enda fil och ändå bevisa vem som utfärdade det, till vem och för vad.

Den här guiden förklarar vad baking är, var datan finns i filen, hur en verifierare läser tillbaka den och vad du behöver ta ställning till som utfärdare av meriter. Du behöver inte skriva någon kod för att använda bakade märken. Om du utfärdar via https://badges.ninja sker baking åt dig. Men att förstå mekaniken hjälper dig svara på de frågor som mottagare och arbetsgivare faktiskt ställer: ”Är den här bilden äkta?” och ”Kan vem som helst bara kopiera den?”

Vad ”baking” betyder

En Open Badge har två delar som lätt blandas ihop:

  • Bilden. PNG- eller SVG-filen som folk ser på en profil, en bild i en presentation eller ett certifikat.
  • Assertion. Ett litet JSON-dokument som anger fakta: vem mottagaren är (som en hashad identifierare), vilken märkesklass som uppnåtts, vem som utfärdade det, när och var det kan verifieras.

Baking är handlingen att skriva in assertion i bilden så att de två inte kan skiljas åt. Resultatet är en enda fil. Ger du någon PNG-filen har du gett både bilden och påståendet bakom den.

Idén kommer från Open Badges-specifikationen, som ursprungligen utvecklades av Mozilla och nu underhålls av 1EdTech. Poängen med designen är portabilitet. Till en början levde märken inuti en enda plattform, och att flytta ett märke till en ny plats innebar att ladda upp det igen och hoppas att metadatan överlevde. En bakad fil bär med sig sin egen metadata vart den än tar vägen.

Var JSON finns inuti en PNG

En PNG-fil är en kort signatur följd av en följd av chunks. Varje chunk har en längd, en typ på fyra bokstäver, lite data och en kontrollsumma. Bildvisare ritar pixlarna från IDAT-chunks och ignorerar chunktyper de inte förstår. Den toleransen är det som gör baking möjlig: du kan lägga till en chunk full av text och alla bildvisare i världen visar ändå bilden som vanligt.

För Open Badges 2.0 läggs assertion i en textchunk med nyckelordet openbadges. Textchunktyperna som kan rymma den är:

ChunkKodningAnteckningar
tEXtLatin-1Enkel, men begränsad till Latin-1-tecken.
iTXtUTF-8Att föredra, eftersom namn och beskrivningar ofta inte är ASCII.

Oavsett vilken chunk som används är upplägget detsamma: nyckelordet openbadges, en avgränsare och sedan innehållet. Innehållet är en av två saker, beroende på hur utfärdaren valde att baka:

  1. Själva assertion-JSON. Filen är självbeskrivande. En verifierare kan läsa påståendet utan något nätverksanrop.
  2. En URL som pekar på den hostade assertion. Filen blir mindre och utfärdaren kan behålla den levande posten som auktoritativ, till exempel för att visa att ett märke senare har återkallats eller har gått ut.

En tredje variant finns för signerade märken, där innehållet är en signerad token i stället för vanlig JSON. Om signaturer är viktiga för ditt användningsfall, läs hur du verifierar en Open Badge-signatur.

Hur är det med SVG?

SVG-märken kan också bakas, eftersom SVG är XML. Assertion placeras i filen i ett element i XML-namnrymden openbadges, och attributet verify bär URL:en till den hostade assertion. Principen är densamma som för PNG: metadatan åker med inuti bildfilen. I praktiken bakar de flesta plattformar PNG, eftersom PNG accepteras nästan överallt där folk vill ladda upp ett märke.

Hur den inbäddade assertion ser ut

För 2.0-formatet är en hostad assertion JSON-LD som länkar mottagaren, märkesklassen och verifieringsmetoden. Ett kortat exempel:

{
  "@context": "https://w3id.org/openbadges/v2",
  "type": "Assertion",
  "id": "https://example.org/assertions/abc123",
  "recipient": {
    "type": "email",
    "hashed": true,
    "salt": "deadsea",
    "identity": "sha256$c7ef86405ba71b85acd8e2e95166c4b111448089f2e1599f42fe1bba46e865c5"
  },
  "badge": "https://example.org/badges/data-analysis-101",
  "issuedOn": "2026-05-14T00:00:00Z",
  "verification": { "type": "hosted" }
}

Lägg märke till mottagaren. E-postadressen lagras inte i klartext; den är en saltad SHA-256-hash. Det spelar roll för en fil som är gjord för att spridas. Alla som har PNG-filen kan läsa assertion, så den får inte läcka mottagarens adress. En verifierare som redan känner till e-postadressen kan hasha den med samma salt och kontrollera att den stämmer. För en genomgång fält för fält av dokumentet, se genomgången av Open Badge JSON-LD.

Så läser en verifierare ett bakat märke

Verifiering av ett bakat märke är en kort, mekanisk process:

  1. Öppna PNG-filen och gå igenom dess chunks.
  2. Hitta textchunken med nyckelordet openbadges.
  3. Läs innehållet. Om det är JSON, tolka det. Om det är en URL, hämta den.
  4. Kontrollera att assertion hänvisar till den märkesklass och utfärdare du förväntar dig, och att mottagarens identitet matchar personen som visar upp den.
  5. Om verifieringstypen är hosted, bekräfta att den hostade assertion fortfarande finns på sin id-URL och inte har återkallats eller gått ut.

Steg 5 är det som folk hoppar över, och det är det som gör en merit trovärdig. En inbäddad kopia är en ögonblicksbild. Den hostade posten är sanningskällan.

Läs den själv i Node

Du kan granska vilken PNG som helst med ett kort skript. Det här går igenom chunks och skriver ut openbadges-innehållet, med stöd för både tEXt och iTXt:

import { readFileSync } from "node:fs";
import { inflateSync } from "node:zlib";
const png = readFileSync(process.argv[2]);
let pos = 8; // skip the 8-byte PNG signature
while (pos < png.length) {
  const length = png.readUInt32BE(pos);
  const type = png.toString("ascii", pos + 4, pos + 8);
  const data = png.subarray(pos + 8, pos + 8 + length);
  if (type === "iTXt" || type === "tEXt") {
    const nul = data.indexOf(0);
    const keyword = data.toString("latin1", 0, nul);
    if (keyword === "openbadges") {
      let text;
      if (type === "tEXt") text = data.toString("latin1", nul + 1);
      else {
        const compressed = data[nul + 1] === 1;
        let p = nul + 3; // skip compression flag + method
        p = data.indexOf(0, p) + 1; // language tag
        p = data.indexOf(0, p) + 1; // translated keyword
        const body = data.subarray(p);
        text = (compressed ? inflateSync(body) : body).toString("utf8");
      }
      console.log(text);
      process.exit(0);
    }
  }
  pos += 12 + length; // length + type + data + CRC
}
console.error("No openbadges chunk found: this PNG is not baked.");
process.exit(1);

Kör det med node extract-badge.mjs my-badge.png. Om filen är bakad ser du JSON eller en URL. Om inte får du ett enkelt ”not baked”-meddelande. Det här är ett undervisningsverktyg, inte en fullständig validerare: det kontrollerar inte chunkarnas kontrollsummor, tolkar inte signerat innehåll och hämtar inte den hostade posten.

Om du hellre inte skriver kod visar en online-märkesvaliderare eller en PNG-metadatavisare samma chunk. Formatet är standarden, så alla kompatibla verktyg läser alla kompatibla märken.

Varför baking spelar roll

Portabilitet. En merit som bara är en PNG kan mejlas, laddas upp till en lärplattform eller sparas i ett personligt arkiv. Inget konto behövs för att bära den.

En verifieringsväg som överlever utfärdarens marknadsföringssajt. Den inbäddade assertion namnger utfärdaren och pekar på den hostade posten, så en verifierare kan utgå från enbart filen.

Offline- och lowtech-flöden. När innehållet är hela JSON kan en läsare kontrollera påståendet på en maskin utan nätverk och verifiera den hostade posten senare.

Bevis som är svårt att förfalska på lösa boliner. Vem som helst kan ta en skärmdump av ett märke. En skärmdump har ingen metadata och kan därför inte verifieras som en märkesfil. Det skiljer redan en äkta merit från en kopierad bild. Det hindrar inte någon från att baka in en förfalskad assertion i en stulen bild, och därför finns steget med hostad verifiering.

Bakingens gränser

Var ärlig mot dina mottagare om dessa, eftersom de påverkar hur du beskriver dina meriter.

  • Metadata tas bort. Många sociala nätverk, bildoptimerare och meddelandeappar kodar om uppladdningar och släpper chunks som inte är pixlar. Ett bakat märke som postas i ett socialt flöde är oftast inte längre bakat. Det är väntat, och det är därför en publik verifieringslänk är viktig vid sidan av filen.
  • Baking är inte ett bevis i sig. Inbäddad JSON kan skrivas av vem som helst. Förtroendet kommer från den hostade assertion på utfärdarens domän, eller från en giltig signatur.
  • Bildredigering bryter länken. Att ändra storlek eller spara om i ett redigeringsprogram kan förlora chunken.
  • Bara PNG och SVG. JPEG har ingen motsvarande chunkkonvention i specifikationen, så ett fotoliknande märke exporterat som JPEG kan inte bakas på standardsättet.

Den praktiska slutsatsen: behandla den bakade filen som en bekväm bärare och verifieringssidan som auktoriteten. Om du väger format för ditt program förklarar Open Badges vs PDF-certifikat varför en maskinläsbar merit slår ett statiskt dokument.

Så fungerar baking på https://badges.ninja

När du tilldelar ett märke på https://badges.ninja bygger plattformen Open Badge-assertion för den mottagaren och bakar in den i märkesbilden som en del av utfärdandet. Du konfigurerar inget verktyg och kör inget kommando. Flödet:

  1. Du designar märket i den visuella designern, eller laddar upp din egen bild.
  2. Du utfärdar en tilldelning, från dashboarden, från en CSV-uppladdning för massutdelningar eller via API:et.
  3. Plattformen skapar assertion, bakar in den i PNG-filen och lagrar resultatet tillsammans med tilldelningen.
  4. Mottagaren får en publik verifieringssida på https://badges.ninja/awards/<awardId>, ett PDF-certifikat, en QR-kod och ett Add to LinkedIn-alternativ.

Om märkets design använder sammanfogningsfält som mottagarens namn får varje tilldelning en personlig bild, och det är den personliga bilden som bakas.

Baking behandlas som en förbättring av utfärdandet, inte som en spärr: om en viss bild inte kan bakas (till exempel en degenererad platshållarbild) utfärdas tilldelningen ändå med originalbilden, och den publika verifieringssidan och Open Badge JSON-LD påverkas inte. Bilden du laddar upp måste också klara en minimistorlek, så en pytteliten tom canvas avvisas innan den når bageriet.

Eftersom den publika sidan är auktoriteten kan vem som helst kontrollera en tilldelning utan att registrera sig. Den maskinläsbara Open Badge v2.0 JSON-LD för en tilldelning finns på https://api.badges.ninja/certify-badge/award/<awardId>.

Utfärda en tilldelning via API

De flesta läsare använder dashboarden, men om du automatiserar utfärdandet skapar en enda förfrågan tilldelningen (och den bakade bilden följer med). Byt ut nyckeln och märkes-id:t mot dina egna:

const res = await fetch("https://api.badges.ninja/awards", {
  method: "POST",
  headers: { "X-Api-Key": "bws_YOUR_KEY_HERE", "Content-Type": "application/json" },
  body: JSON.stringify({
    badgeId: "your-badge-id",
    recipient: { name: "Jane Smith", email: "jane@example.com" },
    issuedOn: Date.now(),
  }),
});
const { awardId } = await res.json();
const verifyUrl = `https://badges.ninja/awards/${awardId}`;

Anropet returnerar HTTP 200 med { "awardId": "<guid>" }. Bygg verifierings-URL:en från det id:t. För nyckelinställning och den fullständiga förfrågningsreferensen, se dokumentationen för Awards API och autentiseringsguiden.

Badge detail screen in the https://badges.ninja dashboard

Praktiska råd till utfärdare

Publicera alltid en verifieringslänk bredvid filen. Lägg länken i tilldelningsmejlet, på certifikatet och på varje sida där märket visas. Eftersom sociala plattformar tar bort metadata är det länken som håller meriten verifierbar efter delning.

Använd en ren källbild med rimlig storlek. Utgå från en PNG med riktiga mått. Ett märke som en designer gjort i normal upplösning bakas pålitligt; en platshållare på 1 pixel gör det inte.

Redigera inte den levererade filen. Be mottagarna dela den ursprungliga nedladdningen eller verifieringslänken, inte en beskuren skärmdump.

Bestäm vad du vill säga om återkallelse och utgång. Eftersom den hostade posten är auktoritativ kan en bakad fil överleva meritens status. Säg det tydligt i din programdokumentation så att arbetsgivare vet att de ska kontrollera verifieringssidan i stället för att lita enbart på filen.

Testa ett märke från början till slut. Utfärda en tilldelning till dig själv, ladda ner PNG-filen, kör den genom skriptet ovan eller en publik validerare och öppna verifieringslänken. Fem minuters testande visar vad dina mottagare kommer att uppleva.

List of badges in the https://badges.ninja dashboard

Vanliga frågor

Är ett bakat märke samma sak som ett digitalt certifikat? Nej. Ett certifikat är oftast en PDF för läsning och utskrift. Ett bakat märke är en bild som också bär maskinläsbar meritdata. https://badges.ninja skapar båda från samma tilldelning.

Kan jag baka ett märke utan en plattform? Ja. Specifikationen är öppen och bibliotek finns för flera språk. Den svårare delen är att hosta assertion på en stabil URL, vilket är det som gör verifieringen meningsfull. Den delen sköter en plattform åt dig.

Avslöjar baking mottagarens e-postadress? Inte när identiteten är hashad. Assertion lagrar en saltad hash, så filen avslöjar inte adressen.

Läser LinkedIn den bakade datan? LinkedIns Add to Profile-flöde utgår från meritens namn, utfärdare, datum och URL snarare än från filens metadata. Se att lägga till en Add to LinkedIn-knapp.

Sammanfattning

Ett bakat Open Badge är en PNG (eller SVG) med meriten skriven i en textchunk som heter openbadges. Det gör ett märke portabelt och självbeskrivande, men det verkliga förtroendet kommer från den hostade assertion på utfärdarens domän. Baka för portabilitet, publicera en verifieringslänk för förtroende och räkna med att sociala nätverk tar bort metadatan.

Redo att utfärda din första verifierbara merit? Börja gratis på badges.ninja — visuell designer, publik verifieringssida, PDF-certifikat, Open Badge v2.0-utdata. Inget kreditkort krävs.

Nacho Coll

Om författaren

Founder & Engineer at Badges Ninja

Nacho founded Badges Ninja to make issuing verifiable digital credentials as simple as a single API call — Open Badge v2.0 badges and certificates, minted, hosted, and verifiable without standing up your own issuer infrastructure. Writes about the Open Badges spec, credential verification, and running a credentialing platform serverless on AWS, from the operator side of the wire.

Tillbaka till Bloggen

Relaterade artiklar