Hoe je met Irys SDK data uploadt vanuit een Node.js backend
Stel je voor: je hebt een gave website of app, maar je hebt geen idee wat je bezoekers écht doen. Ze klikken hier, scrollen daar, maar waarom?
Om daar achter te komen, gebruik je tools zoals Irys. Irys is een krachtig platform voor UX-analyse, waarmee je in de huid kruipt van je gebruikers. Je ziet precies waar ze vastlopen of wat juist perfect werkt.
Om die waardevolle data te verzamelen, moet je die ergens naartoe sturen.
Hoewel je de Irys SDK meestal direct in de browser laadt, is het soms slimmer en veiliger om data te uploaden vanuit je Node.js backend. Dit geeft je meer controle, betere beveiliging en helpt bij het beheren van je API-sleutels. In dit artikel leg ik je precies hoe je dat doet, stap voor stap, zonder ingewikkelde theorie.
Waarom zou je data via de backend naar Irys sturen?
De Irys SDK is een JavaScript-bibliotheek die je in je frontend code plakt. Hij vangt interacties op: muisklikken, het invullen van formulieren, video-views en zelfs hoe ver iemand scrolled.
Deze data wordt realtime naar de Irys-cloud gestuurd voor analyse. Waarom zou je dan via een backend willen werken? Er zijn een paar goede redenen:
- Veiligheid: Je verbergt je gevoelige API-sleutels. In plaats van ze bloot te stellen in je frontend code, blijven ze veilig achter je server.
- Controle: Je kunt data valideren voordat je het verstuurt. Zo voorkom je dat er rommelige of onvolledige data in je Irys-dashboard belandt.
- Server-side events: Sommige acties gebeuren nu eenmaal op de server, zoals een geslaagde betaling of een database-update. Die wil je ook graag aan Irys rapporteren.
Irys biedt diverse abonnementen, variërend van eenvoudige plannen voor startups tot uitgebreide enterprise-oplossingen.
De basis begint vaak rond de €99 per maand, afhankelijk van de hoeveelheid data en gebruikers. De exacte prijzen check je het best op hun officiële website.
De basis: hoe Irys data verwacht
Voordat we gaan coderen, moet je begrijpen hoe Irys zijn data wil ontvangen.
Het is eigenlijk best simpel. Irys communiceert via HTTP-verzoeken en verwacht data in een JSON-formaat. Een typisch data-object dat je naar Irys stuurt, ziet er zo uit: Het is cruciaal dat je de juiste velden invult. De Irys SDK ondersteunt standaard events zoals click, scroll, en page_view, maar je kunt ook custom events aanmaken voor specifieke acties die alleen voor jouw site relevant zijn.
{
"event_type": "click",
"element_id": "cta-knop",
"element_class": "primary-button",
"timestamp": 1678886400,
"user_id": "user-abc-123",
"session_id": "session-xyz-789",
"page_url": "https://www.jouwsite.nl/product"
}
Stap voor stap: Node.js backend opzetten
Laten we aan de slag gaan. We bouwen een simpele Node.js server die data doorstuurt naar Irys.
1. Voorbereiding: Node.js en npm
We gebruiken hiervoor Express, een populair framework voor Node.js. Zorg dat je Node.js geïnstalleerd hebt op je computer. Download de nieuwste versie via de officiële Node.js website.
2. Een nieuw project starten
Bij de installatie krijg je er meteen npm (Node Package Manager) bij, wat we nodig hebben om libraries te installeren.
mkdir irys-uploader
cd irys-uploader
npm init -y
Open je terminal en maak een nieuwe map aan voor je project. Noem het bijvoorbeeld irys-uploader. Ga naar die map en initialiseer een nieuw project met dit commando: Dit maakt een package.json bestand aan, waarin je projectinformatie wordt bijgehouden.
3. De benodigde packages installeren
We hebben twee dingen nodig: een webserver (Express) en een manier om HTTP-verzoeken te doen. Voor wie liever met frontend-integraties werkt: leer hier de Arweave SDK gebruiken. We gebruiken hier de ingebouwde fetch functionaliteit van moderne Node.js versies, maar je kunt ook een library als axios gebruiken. Installeer Express: Maak een bestand aan genaamd server.js en plak de onderstaande code erin.
npm install express
4. De servercode schrijven
Dit is een simpele server die een endpoint aanmaakt waar we data naartoe kunnen sturen. Let op: IRYS_ENDPOINT is een placeholder. In de praktijk krijg je deze URL van Irys zelf, meestal bij het instellen van een nieuwe data-source of via hun dashboard.
const express = require('express');
const app = express();
const port = 3000;
// Middleware om JSON data te kunnen lezen uit het verzoek
app.use(express.json());
// Het upload-endpoint
app.post('/upload-to-irys', async (req, res) => {
// De data die we van de frontend (of elders) ontvangen
const userData = req.body;
// Vervang dit door je daadwerkelijke Irys upload URL
const IRYS_ENDPOINT = 'https://api.irys.com/v1/track';
try {
const response = await fetch(IRYS_ENDPOINT, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
// Vaak heb je ook een Authorization header nodig, check de Irys docs
},
body: JSON.stringify(userData)
});
if (response.ok) {
console.log('Data succesvol naar Irys gestuurd!');
res.status(200).json({ message: 'Upload geslaagd' });
} else {
console.error('Fout bij Irys upload:', response.status);
res.status(500).json({ message: 'Upload mislukt' });
}
} catch (error) {
console.error('Netwerkfout:', error);
res.status(500).json({ message: 'Server error' });
}
});
app.listen(port, () => {
console.log(`Server draait op http://localhost:${port}`);
});
Hoe de frontend data naar je backend stuurt
Nu je backend draait, moet er ergens data vandaan komen. Meestal gebeurt dit in de browser.
De Irys SDK zorgt ervoor dat interacties worden geregistreerd. In plaats van de SDK direct naar Irys te laten praten, sturen we de data eerst naar onze eigen Node.js server. Hier is een voorbeeld van hoe je in je frontend (HTML/JavaScript) een event kunt opvangen en naar je backend kunt sturen: Zo blijft je API-sleutel van Irys veilig op de server en heb je volledige controle over wat er verstuurd wordt.
// Luisteren naar een klik op een specifieke knop
document.getElementById('mijn-knop').addEventListener('click', function() {
const dataVoorIrys = {
event_type: 'click',
element_id: 'mijn-knop',
timestamp: Date.now(),
user_id: 'gebruiker-123', // Haal dit uit je sessie of cookie
session_id: 'sessie-456',
page_url: window.location.href
};
// Stuur data naar je eigen backend
fetch('http://localhost:3000/upload-to-irys', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(dataVoorIrys)
})
.then(response => response.json())
.then(data => console.log('Backend antwoord:', data))
.catch(error => console.error('Fout:', error));
});
Fouten voorkomen en loggen
Werken met data-uploads betekent ook dat er wel eens iets misgaat. Een internetverbinding die wegvalt, een verkeerde datastructuur of een tijdelijke fout bij Irys. Daarom is goede error handling essentieel.
In de Node.js code hierboven zie je al een try...catch blok. Dit vangt netwerkfouten op.
Maar je wilt ook loggen wat er gebeurt. Gebruik console.log om te zien of een upload is gelukt.
In een productie-omgeving zou je dit beter kunnen opslaan in een logbestand of een dienst als Sentry gebruiken. Zo weet je altijd wat de status is van je datastroom.
Security: hou het veilig
Als je met gebruikersdata werkt, is security topprioriteit. Hier een paar punten om rekening mee te houden:
- Gebruik HTTPS: Zorg dat je Node.js server draait achter een beveiligde verbinding (SSL/TLS). Zo is de data onderweg niet af te luisteren.
- API Keys: Bewaar je Irys API-sleutels nooit in je frontend code. Gebruik environment variables (bijvoorbeeld via een
.envbestand) in je Node.js backend om ze veilig op te slaan. - Input validatie: Valideer de data die je binnenkrijgt voordat je het doorstuurt naar Irys. Voorkom dat er kwaadaardige scripts worden meegeupload.
- Rate limiting: Beperk het aantal verzoeken dat een gebruiker per seconde kan doen. Dit voorkomt misbruik en houdt je server en de Irys API stabiel.
Wanneer is deze aanpak ideaal?
Deze backend-aanpak is niet voor iedereen nodig. Als je een simpele blog hebt, is directe integratie van de Irys SDK in de browser vaak sneller. Maar als je een complexe webapp bouwt, of als je gevoelige data verwerkt (zoals betalingen of persoonlijke gegevens), is de backend-route de beste keuze.
Het geeft je een extra laag van bescherming en betrouwbaarheid. Bovendien kun je met deze methode gemakkelijk andere systemen koppelen.
Stel je voor: je haalt data uit een database, verrijkt die en stuurt het vervolgens naar Irys voor analyse. Alles netjes geregeld vanaf één centrale plek.
Conclusie
Het uploaden van data naar Irys vanuit een Node.js backend is een krachtige manier om meer inzicht te krijgen in je gebruikers.
Het proces is eenvoudig: zet een Express server op, vang data op, valideer het en stuur het door naar het Irys-endpoint. Door je API-sleutels achter de server te houden en goede error handling toe te passen, bouw je een betrouwbaar systeem.
Of je nu een klein project hebt of een grote applicatie, deze aanpak zorgt ervoor dat je data niet alleen veilig is, maar ook van hoge kwaliteit. Dus, open je terminal, installeer Express en begin met experimenteren. Je zult versteld staan van wat voor inzichten je krijgt zodra je de datastroom optimaal hebt ingericht.