Je eerste mail via Wesender.
" }' ``` ### Node.js ```bash npm install @wesender/node ``` ```typescript import { Wesender } from "@wesender/node" const ws = new Wesender(process.env.WS_API_KEY!) const { id } = await ws.emails.send({ from: "noreply@joudomein.nl", to: ["jij@voorbeeld.nl"], subject: "Hallo van Wesender", html: "Je eerste mail via Wesender.
", }) console.log("Verstuurd:", id) ``` ### Respons ```json { "id": "em_01hwxxxxxxxxxxxxxx", "object": "email" } ``` --- # Domein instellen Voordat je e-mails kunt versturen moet je een afzenderdomein toevoegen en DNS-records instellen. Wesender verifieert de records automatisch zodra ze zijn gepropageerd. ## Stap 1: Domein toevoegen Ga naar Domeinen in het dashboard en voeg het (sub)domein toe. Gebruik bij voorkeur een subdomein zoals `mail.joudomein.nl`. ## Stap 2: DNS-records instellen ### SPF-record ``` Type: TXT Naam: mail.joudomein.nl Waarde: v=spf1 include:spf.wesender.nl ~all ``` Als je al een SPF-record hebt, voeg dan `include:spf.wesender.nl` toe aan het bestaande record. ### DKIM-record ``` Type: TXT Naam: postal-wesender._domainkey.mail.joudomein.nl Waarde: v=DKIM1; k=rsa; p=Hoi Alice.
" }, { "from": "noreply@joudomein.nl", "to": ["bob@voorbeeld.nl"], "subject": "Wekelijks rapport", "html": "Hoi Bob.
" } ]' ``` ### Node.js ```typescript const results = await ws.emails.sendBatch([ { from: "noreply@joudomein.nl", to: ["alice@voorbeeld.nl"], subject: "Rapport", html: "Hoi Alice.
" }, { from: "noreply@joudomein.nl", to: ["bob@voorbeeld.nl"], subject: "Rapport", html: "Hoi Bob.
" }, ]) // results[0].id, results[1].id ``` ## Respons ```json HTTP/1.1 201 Created [ { "id": "em_01hwaaaaaaaaaa", "object": "email" }, { "id": "em_01hwbbbbbbbbbb", "object": "email" } ] ``` --- # Bijlagen Stuur bestanden mee via het `attachments`-veld in de verzoekbody van `POST /emails`. ## Velden per bijlage | Veld | Type | Verplicht | Beschrijving | |--------------|--------|-----------|-------------------------------------| | filename | string | Ja | Bestandsnaam inclusief extensie | | content | string | Ja | Bestandsinhoud als Base64-string | | content_type | string | Nee | MIME-type, bijv. `application/pdf` | ## Voorbeeld ```typescript import { readFileSync } from "fs" await ws.emails.send({ from: "noreply@joudomein.nl", to: ["klant@voorbeeld.nl"], subject: "Je factuur", html: "Zie bijlage.
", attachments: [{ filename: "factuur-2026-01.pdf", content: readFileSync("./factuur.pdf").toString("base64"), content_type: "application/pdf", }], }) ``` ## Ondersteunde bestandstypen Elk MIME-type wordt ondersteund: PDF, afbeeldingen (PNG, JPEG, GIF), CSV, DOCX, ZIP en andere. --- # Domeinen Beheer je verzenderdomeinen via de REST API. ## Domeinen ophalen **GET** `https://api.wesender.nl/domains` ```bash curl https://api.wesender.nl/domains \ -H "Authorization: Bearer $WS_API_KEY" ``` Respons: array van domeinobjecten met `id`, `name`, `status` en `records`. ## Domein toevoegen **POST** `https://api.wesender.nl/domains` ```json { "name": "mail.joudomein.nl" } ``` Respons: domeinobject inclusief de te configureren DNS-records. ## Domein verwijderen **DELETE** `https://api.wesender.nl/domains/:id` ```bash curl -X DELETE https://api.wesender.nl/domains/dom_01hwxxxxxxxxxx \ -H "Authorization: Bearer $WS_API_KEY" ``` ## Domeinstatussen - `pending`: DNS-records nog niet geverifieerd - `active`: alle records geverifieerd, klaar voor verzending - `failed`: verificatie mislukt --- # Node.js / TypeScript SDK Officiële SDK met volledige TypeScript-types en async/await. Werkt met Node.js 18+, Bun en Deno. GitHub: https://github.com/wesender/wesender-node ## Installatie ```bash npm install @wesender/wesender-node # of bun add @wesender/wesender-node ``` ## Initialisatie ```typescript import { Wesender } from "@wesender/wesender-node" export const ws = new Wesender(process.env.WS_API_KEY!) ``` ## E-mail versturen ```typescript const { id, status } = await ws.emails.send({ from: "noreply@joudomein.nl", to: "klant@voorbeeld.nl", subject: "Welkom!", html: "Bedankt voor je registratie.
", }) // id: "em_01hw...", status: "queued" ``` ## Meerdere ontvangers en CC ```typescript await ws.emails.send({ from: "noreply@joudomein.nl", to: ["a@voorbeeld.nl", "b@voorbeeld.nl"], cc: ["manager@bedrijf.nl"], bcc: ["audit@bedrijf.nl"], subject: "Maandelijks rapport", html: "Zie bijlage.
", }) ``` ## Batch versturen ```typescript const results = await ws.emails.sendBatch([ { from: "noreply@joudomein.nl", to: "a@voorbeeld.nl", subject: "Rapport", html: "Hoi A.
" }, { from: "noreply@joudomein.nl", to: "b@voorbeeld.nl", subject: "Rapport", html: "Hoi B.
" }, ]) ``` --- # Python SDK Officiële Python SDK voor Wesender. ## Installatie ```bash pip install wesender ``` ## Gebruik ```python import os from wesender import Wesender ws = Wesender(os.environ["WS_API_KEY"]) response = ws.emails.send({ "from": "noreply@joudomein.nl", "to": ["klant@voorbeeld.nl"], "subject": "Welkom!", "html": "Bedankt voor je registratie.
", }) print(response.id) ``` ## Batch versturen ```python results = ws.emails.send_batch([ {"from": "noreply@joudomein.nl", "to": ["a@voorbeeld.nl"], "subject": "Rapport", "html": "Hoi A.
"}, {"from": "noreply@joudomein.nl", "to": ["b@voorbeeld.nl"], "subject": "Rapport", "html": "Hoi B.
"}, ]) ``` --- # PHP SDK Officiële PHP SDK voor Wesender. ## Installatie ```bash composer require wesender/wesender-php ``` ## Gebruik ```php emails->send([ 'from' => 'noreply@joudomein.nl', 'to' => ['klant@voorbeeld.nl'], 'subject' => 'Welkom!', 'html' => 'Bedankt voor je registratie.
', ]); echo $response->id; ``` --- # Go SDK Officieel Go-pakket voor Wesender. ## Installatie ```bash go get github.com/wesender/wesender-go ``` ## Gebruik ```go package main import ( "context" "os" "github.com/wesender/wesender-go" ) func main() { ws := wesender.New(os.Getenv("WS_API_KEY")) resp, err := ws.Emails.Send(context.Background(), wesender.SendEmailParams{ From: "noreply@joudomein.nl", To: []string{"klant@voorbeeld.nl"}, Subject: "Welkom!", HTML: "Bedankt.
", }) if err != nil { panic(err) } _ = resp.ID } ``` --- # Ruby SDK Officieel Ruby-gem voor Wesender. ## Installatie ```bash gem install wesender ``` ## Gebruik ```ruby require "wesender" ws = Wesender::Client.new(ENV["WS_API_KEY"]) response = ws.emails.send( from: "noreply@joudomein.nl", to: ["klant@voorbeeld.nl"], subject: "Welkom!", html: "Bedankt voor je registratie.
" ) puts response.id ``` --- # Rust SDK Officieel Rust-crate voor Wesender. ## Installatie ```toml [dependencies] wesender = "1" ``` ## Gebruik ```rust use wesender::{Wesender, SendEmailParams}; #[tokio::main] async fn main() { let ws = Wesender::new(std::env::var("WS_API_KEY").unwrap()); let resp = ws.emails().send(SendEmailParams { from: "noreply@joudomein.nl".into(), to: vec!["klant@voorbeeld.nl".into()], subject: "Welkom!".into(), html: Some("Bedankt.
".into()), ..Default::default() }).await.unwrap(); println!("{}", resp.id); } ``` --- # Java SDK Officieel Java-pakket voor Wesender. ## Installatie ### Maven ```xmlBedankt.
") .build(); String id = ws.emails().send(params).getId(); ``` --- # .NET / C# SDK Officieel .NET-pakket voor Wesender. ## Installatie ```bash dotnet add package Wesender ``` ## Gebruik ```csharp using Wesender; var ws = new WesenderClient(Environment.GetEnvironmentVariable("WS_API_KEY")!); var response = await ws.Emails.SendAsync(new SendEmailParams { From = "noreply@joudomein.nl", To = new[] { "klant@voorbeeld.nl" }, Subject = "Welkom!", Html = "Bedankt voor je registratie.
", }); Console.WriteLine(response.Id); ``` --- # Elixir SDK Officieel Elixir-pakket voor Wesender. ## Installatie ```elixir # mix.exs def deps do [ {:wesender, "~> 1.0"} ] end ``` ## Gebruik ```elixir {:ok, %{id: id}} = Wesender.Emails.send(%{ from: "noreply@joudomein.nl", to: ["klant@voorbeeld.nl"], subject: "Welkom!", html: "Bedankt voor je registratie.
" }) IO.puts(id) ``` --- # SMTP-relay Naast de REST API ondersteunt Wesender ook SMTP. Gebruik dit als je een bestaande applicatie hebt die via SMTP verstuurt. ## Instellingen | Instelling | Waarde | |----------------|--------------------------------------------| | Server | smtp.wesender.nl | | Poort | 587 (STARTTLS, aanbevolen) of 465 (SSL/TLS)| | Gebruikersnaam | Jouw geverifieerde afzenderadres | | Wachtwoord | Jouw API-key (ws_live_...) | | Beveiliging | STARTTLS of SSL/TLS | ## Nodemailer (Node.js) ```javascript import nodemailer from "nodemailer" const transporter = nodemailer.createTransport({ host: "smtp.wesender.nl", port: 587, secure: false, auth: { user: "noreply@joudomein.nl", pass: process.env.WS_API_KEY, }, }) await transporter.sendMail({ from: "noreply@joudomein.nl", to: "klant@voorbeeld.nl", subject: "Welkom!", html: "Bedankt voor je aanmelding.
", }) ``` ## PHPMailer ```php isSMTP(); $mail->Host = 'smtp.wesender.nl'; $mail->SMTPAuth = true; $mail->Username = 'noreply@joudomein.nl'; $mail->Password = getenv('WS_API_KEY'); $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; $mail->Port = 587; ``` ## Compatibel met Laravel (Mail), Django (EMAIL_HOST), WordPress (WP Mail SMTP), Nodemailer, PHPMailer, Postfix en vrijwel elk ander systeem dat SMTP ondersteunt. --- # Webhooks Ontvang realtime HTTP POST-verzoeken bij e-mailactiviteit. ## Webhook aanmaken ```bash curl -X POST https://api.wesender.nl/webhooks \ -H "Authorization: Bearer $WS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "url": "https://joudomein.nl/webhooks/wesender", "events": ["email.delivered", "email.bounced", "email.opened", "email.clicked", "email.failed"] }' ``` ## Beschikbare events | Event | Wanneer | |-----------------|------------------------------------------| | email.delivered | Bezorgd in de inbox van de ontvanger | | email.bounced | Permanent geweigerd (hard bounce) | | email.opened | Ontvanger heeft de e-mail geopend | | email.clicked | Ontvanger heeft een link geklikt | | email.failed | Tijdelijk leveringsprobleem | ## Payloads ### email.delivered ```json { "type": "email.delivered", "created_at": "2026-06-13T09:19:31Z", "data": { "id": "av276ywjkg15k2ku9j1xgrqe", "from": "noreply@joudomein.nl", "to": ["klant@voorbeeld.nl"], "subject": "Je bestelling is verzonden" } } ``` ### email.bounced ```json { "type": "email.bounced", "created_at": "2026-06-13T09:21:07Z", "data": { "id": "av276ywjkg15k2ku9j1xgrqe", "to": ["ongeldig@voorbeeld.nl"], "bounce_type": "hard", "bounce_message": "550 5.1.1 The email account does not exist" } } ``` ### email.clicked ```json { "type": "email.clicked", "created_at": "2026-06-13T09:26:01Z", "data": { "id": "av276ywjkg15k2ku9j1xgrqe", "click_url": "https://joudomein.nl/bestellingen/12345" } } ``` ## Verifieer de handtekening Elke payload bevat een HMAC-handtekening in de `X-Wesender-Signature`-header. Verifieer die om te bevestigen dat het verzoek van Wesender afkomstig is. --- # CLI Stuur e-mails en beheer je account vanuit de terminal. ## Installatie ```bash npm install -g @wesender/wesender-cli ``` ## Configuratie ```bash # API-key instellen wesender config set-key ws_live_... # Standaard afzender instellen wesender config set-from noreply@mail.joudomein.nl # Verbinding controleren wesender doctor ``` ## E-mail versturen ```bash wesender send \ --to klant@bedrijf.nl \ --subject "Welkom bij ons platform" \ --html "Bedankt voor je registratie.
" # JSON-output voor scripts wesender send --to x@y.nl --subject "Test" --html "x
" --json ``` ## Domeinen beheren ```bash # Alle domeinen bekijken wesender domains list # Nieuw domein toevoegen wesender domains add mail.joudomein.nl # DNS-status controleren wesender domains verify mail.joudomein.nl ``` ## Logs ```bash # Laatste 50 e-mails wesender logs # Live streamen wesender logs --follow # Filteren op status wesender logs --status bounced --limit 100 ``` ## Authenticatie via omgevingsvariabele ```bash export WS_API_KEY=ws_live_... wesender send --to x@y.nl --subject "Test" --html "x
" ``` --- # Model Context Protocol + WeSender > Bouw een MCP-server die je AI-model rechtstreeks e-mails laat versturen via Wesender. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/mcp ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel (WESENDER_API_KEY) - Node.js 18 of nieuwer - Een MCP-client zoals Claude Desktop of een eigen implementatie ## Integratiestappen ### Stap 1: Installeer de benodigde packages Maak een nieuw Node.js-project aan en installeer de MCP SDK en de Wesender Node.js SDK. ### Stap 2: Definieer de send_email tool Registreer een ListTools-handler die jouw MCP-client vertelt welke tools beschikbaar zijn. De send_email tool accepteert from, to, subject en html. ### Stap 3: Verwerk de tool-aanroep De CallTool-handler ontvangt de argumenten van het AI-model en roept de Wesender API aan. Fouten worden teruggegeven zodat het model ze kan verwerken. ### Stap 4: Start de server en koppel aan je MCP-client Verbind de server met een StdioServerTransport en voeg hem toe aan de configuratie van je MCP-client. ## Volledig voorbeeld (src/index.ts) ```typescript import { Server } from "@modelcontextprotocol/sdk/server/index.js" import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js" import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js" import { Wesender } from "@wesender/node" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const server = new Server( { name: "wesender-mcp", version: "1.0.0" }, { capabilities: { tools: {} } } ) server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [ { name: "send_email", description: "Verstuur een transactionele e-mail via Wesender", inputSchema: { type: "object" as const, properties: { from: { type: "string", description: "Afzenderadres op je geverifieerde domein" }, to: { type: "string", description: "Ontvanger-e-mailadres" }, subject: { type: "string", description: "Onderwerpregel" }, html: { type: "string", description: "HTML-inhoud van het bericht" }, }, required: ["from", "to", "subject", "html"], }, }, ], })) server.setRequestHandler(CallToolRequestSchema, async (request) => { if (request.params.name !== "send_email") { return { isError: true, content: [{ type: "text" as const, text: "Onbekend tool: " + request.params.name }], } } const { from, to, subject, html } = request.params.arguments as Record{{ $json.inhoud }}
" }, "options": { "response": { "response": { "responseFormat": "json" } } } }, "credentials": { "httpHeaderAuth": { "name": "Wesender API" } } } ] } ``` ## Veelgestelde vragen **Kan ik ook HTML-templates met n8n-variabelen gebruiken?** Ja. Bouw de HTML-inhoud op in een Code-node of Function-node vóór de HTTP Request-node. Gebruik n8n-expressies (={{ }}) om waarden dynamisch in te vullen. Geef de ingevulde HTML door als de html-parameter in de body. **Hoe verwerk ik bounces in mijn n8n-flow?** Voeg een Webhook-node toe als ontvangstpunt voor Wesender-events. Stel het webhook-URL in als delivery-webhook in het Wesender-dashboard. Gebruik een IF-node om events met type 'bounced' of 'complained' door te sturen naar een aparte tak in je workflow. **Werkt dit ook met n8n Cloud?** Ja. De HTTP Request-node en Webhook-node zijn beschikbaar in zowel n8n Cloud als zelfgehoste instanties. De enige vereiste is dat het Wesender-webhook-endpoint bereikbaar is vanuit het internet, wat bij n8n Cloud standaard het geval is. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/n8n - Marketingpagina: https://wesender.nl/ai/integraties/n8n - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Anthropic Claude + WeSender > Gebruik Claude's tool use om e-mails te sturen vanuit een AI-agent zonder tussenkomst van de gebruiker. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/anthropic ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - Anthropic API-sleutel (ANTHROPIC_API_KEY) - Node.js 18 of nieuwer ## Integratiestappen ### Stap 1: Installeer de benodigde packages Maak een nieuw Node.js-project aan en installeer de Anthropic SDK en de Wesender Node.js SDK. ### Stap 2: Definieer de send_email-tool Maak een tool-definitie aan. Claude gebruikt het JSON-schema om te begrijpen welke parameters hij moet meegeven bij het versturen van een e-mail. ### Stap 3: Roep Claude aan en verwerk de tool Stuur een gebruikersbericht naar Claude. Als Claude de send_email-tool aanroept, haal je de parameters op en stuur je de e-mail via Wesender. ## Volledig voorbeeld (claude-tool-use.ts) ```typescript import Anthropic from "@anthropic-ai/sdk" import { WesenderClient } from "@wesender/node" const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }) const wesender = new WesenderClient({ apiKey: process.env.WESENDER_API_KEY }) const tools: Anthropic.Tool[] = [ { name: "send_email", description: "Verstuur een transactionele e-mail via Wesender", input_schema: { type: "object", properties: { to: { type: "string", description: "E-mailadres van de ontvanger" }, subject: { type: "string", description: "Onderwerp van de e-mail" }, html: { type: "string", description: "HTML-inhoud van de e-mail" }, }, required: ["to", "subject", "html"], }, }, ] async function runEmailAgent(userMessage: string) { const response = await client.messages.create({ model: "claude-opus-4-8", max_tokens: 1024, tools, messages: [{ role: "user", content: userMessage }], }) for (const block of response.content) { if (block.type === "tool_use" && block.name === "send_email") { const { to, subject, html } = block.input as { to: string; subject: string; html: string } await wesender.emails.send({ from: "noreply@jouwdomein.nl", to, subject, html }) console.log("E-mail verzonden naar", to) } } } runEmailAgent("Stuur een bevestigingsmail naar maria@voorbeeld.nl") ``` ## Veelgestelde vragen **Kan ik meerdere e-mails in een gesprek sturen?** Ja. Voeg het tool_result-blok toe aan de berichten en stuur een vervolgrequest naar Claude. Zolang je de conversation history bijhoudt, kan Claude meerdere keren send_email aanroepen binnen hetzelfde gesprek. **Welk Claude-model moet ik gebruiken?** claude-opus-4-8 biedt de sterkste redenering voor complexe instructies. Voor hogere snelheid bij lagere kosten kun je claude-haiku-4-5-20251001 gebruiken. Beide ondersteunen tool use volledig. **Hoe voorkom ik dat Claude onbedoeld e-mails verstuurt?** Bouw een bevestigingsstap in: verwerk de tool_use-blokken niet automatisch, maar toon de parameters eerst aan de gebruiker. Wacht op goedkeuring voordat je de Wesender API aanroept. Zo blijft de mens in de loop. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/anthropic - Marketingpagina: https://wesender.nl/ai/integraties/anthropic - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Claude Agent SDK + WeSender > Bouw een volwaardige AI-agent met de Claude Agent SDK die zelfstandig e-mails verstuurt als onderdeel van een meerstappenproces. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/claude-agent-sdk ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - Anthropic API-sleutel (ANTHROPIC_API_KEY) - Node.js 20 of nieuwer ## Integratiestappen ### Stap 1: Installeer de Claude Agent SDK Installeer de officiële Claude Agent SDK en de Wesender Node.js SDK in je project. ### Stap 2: Definieer de e-mail-tool Maak een tool-object dat de agent kan gebruiken om e-mails te versturen. De SDK herkent het automatisch als uitvoerbare actie. ### Stap 3: Start de agent met een doel Maak een agent-instantie en geef hem de tools mee. De agent verwerkt de instructie zelfstandig en roept de e-mail-tool aan wanneer dat nodig is. ## Volledig voorbeeld (claude-agent-email.ts) ```typescript import { Agent, tool } from "@anthropic-ai/claude-code" import { WesenderClient } from "@wesender/node" const wesender = new WesenderClient({ apiKey: process.env.WESENDER_API_KEY }) const sendEmailTool = tool({ name: "send_email", description: "Verstuur een transactionele e-mail via Wesender", parameters: { to: { type: "string" as const, description: "Ontvanger e-mailadres" }, subject: { type: "string" as const, description: "Onderwerp" }, html: { type: "string" as const, description: "HTML-inhoud" }, }, execute: async ({ to, subject, html }: { to: string; subject: string; html: string }) => { await wesender.emails.send({ from: "noreply@jouwdomein.nl", to, subject, html }) return { success: true, recipient: to } }, }) const agent = new Agent({ model: "claude-opus-4-8", tools: [sendEmailTool], }) const result = await agent.run( "Verstuur een welkomstmail aan anna@voorbeeld.nl en bas@voorbeeld.nl" ) console.log("Agent klaar:", result.summary) ``` ## Veelgestelde vragen **Wat is het verschil tussen de Claude Agent SDK en gewone tool use?** Bij gewone tool use verwerk je de cyclus handmatig: user message, tool call, tool result, response. De Agent SDK beheert deze cyclus automatisch. De agent kan meerdere tools aanroepen in een keten zonder dat je elke stap hoeft te orchestreren. **Kan de agent meerdere e-mails in een taak versturen?** Ja. De agent kan send_email meerdere keren aanroepen als de instructie daarom vraagt. Je kunt ook een limiet instellen op het aantal tool-aanroepen om onverwacht hoge verzendvolumes te voorkomen. **Hoe log ik wat de agent heeft gedaan?** De Agent SDK retourneert een gedetailleerde trace van alle stappen, inclusief de tool-aanroepen en de resultaten. Sla deze trace op in je eigen logging-systeem voor audits en debugging. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/claude-agent-sdk - Marketingpagina: https://wesender.nl/ai/integraties/claude-agent-sdk - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # LangGraph + WeSender > Modelleer je e-mailworkflow als een toestandsgraph en laat AI-nodes zelfstandig beslissingen nemen over wanneer en wat er verstuurd wordt. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/langgraph ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - OpenAI of Anthropic API-sleutel - Python 3.11 of nieuwer ## Integratiestappen ### Stap 1: Installeer de benodigde packages Installeer LangGraph, LangChain en de requests-bibliotheek voor de Wesender REST API. ### Stap 2: Definieer de toestand en de graph-nodes Maak een TypedDict voor de graph-toestand. Elke node is een Python-functie die de toestand leest, verwerkt en bijgewerkt teruggeeft. ### Stap 3: Bouw en compileer de graph Voeg de nodes toe, stel de edges in en compileer de graph tot een uitvoerbare agent. Roep de graph aan met een beginstand. ## Volledig voorbeeld (langgraph_email.py) ```python import os, requests from typing import TypedDict from langgraph.graph import StateGraph, END from langchain_openai import ChatOpenAI class EmailState(TypedDict): recipient: str subject: str body: str sent: bool def compose_email(state: EmailState) -> EmailState: llm = ChatOpenAI(model="gpt-4o-mini") reply = llm.invoke( f"Schrijf een welkomstmail voor {state['recipient']}. Reageer alleen met de HTML-inhoud." ) return { **state, "body": reply.content } def send_email(state: EmailState) -> EmailState: requests.post( "https://api.wesender.nl/v1/emails", headers={ "Authorization": f"Bearer {os.environ['WESENDER_API_KEY']}" }, json={ "from": "noreply@jouwdomein.nl", "to": state["recipient"], "subject": state["subject"], "html": state["body"], }, ).raise_for_status() return { **state, "sent": True } graph = StateGraph(EmailState) graph.add_node("compose", compose_email) graph.add_node("send", send_email) graph.set_entry_point("compose") graph.add_edge("compose", "send") graph.add_edge("send", END) app = graph.compile() result = app.invoke({ "recipient": "lisa@voorbeeld.nl", "subject": "Welkom bij ons platform", "body": "", "sent": False, }) print("Verstuurd:", result["sent"]) ``` ## Veelgestelde vragen **Kan ik conditionele edges gebruiken om te beslissen of een e-mail wordt verstuurd?** Ja. LangGraph ondersteunt conditionele edges via add_conditional_edges. Je kunt een routeringsfunctie schrijven die de toestand beoordeelt en beslist of de e-mail wordt verstuurd of dat de flow naar een andere node gaat. **Hoe voeg ik menselijke goedkeuring toe aan de graph?** Gebruik LangGraph's interrupt-mechanisme. Voeg interrupt_before=['send'] toe bij het compileren van de graph. De uitvoering pauzeert dan voor de send-node zodat een mens de e-mail kan controleren voordat hij wordt verstuurd. **Kan ik de graph persistent maken over meerdere aanroepen?** Ja. LangGraph ondersteunt checkpointing via SqliteSaver of PostgresSaver. Zo bewaar je de toestand tussen aanroepen en kan de agent doorgaan waar hij gebleven was, ook na een herstart. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/langgraph - Marketingpagina: https://wesender.nl/ai/integraties/langgraph - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # CrewAI + WeSender > Laat een team van AI-agents samenwerken: een schrijver stelt de mail op, een reviewer keurt hem goed en een verzender stuurt hem via Wesender. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/crewai ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - OpenAI API-sleutel (OPENAI_API_KEY) - Python 3.11 of nieuwer ## Integratiestappen ### Stap 1: Installeer CrewAI en dependencies Installeer CrewAI en de requests-bibliotheek voor de Wesender REST API. ### Stap 2: Maak de Wesender-tool Definieer een CrewAI-tool die de Wesender API aanroept. Agents kunnen deze tool gebruiken als ze een e-mail willen versturen. ### Stap 3: Definieer de agents en taken Maak een schrijver-agent en een verzender-agent. Elke agent krijgt een rol en een taak. De crew voert de taken sequentieel uit. ## Volledig voorbeeld (crewai_email.py) ```python import os, requests from crewai import Agent, Task, Crew from crewai.tools import tool @tool("send_email") def send_email(to: str, subject: str, html: str) -> str: """Verstuur een e-mail via Wesender. Geef to, subject en html mee.""" requests.post( "https://api.wesender.nl/v1/emails", headers={ "Authorization": f"Bearer {os.environ['WESENDER_API_KEY']}" }, json={ "from": "noreply@jouwdomein.nl", "to": to, "subject": subject, "html": html }, ).raise_for_status() return f"E-mail verstuurd naar {to}" schrijver = Agent( role="E-mailschrijver", goal="Schrijf een professionele welkomstmail in HTML", backstory="Jij bent een copywriter gespecialiseerd in transactionele e-mails.", verbose=True, ) verzender = Agent( role="E-mailverzender", goal="Verstuur de mail via Wesender", backstory="Jij zorgt dat e-mails correct worden verstuurd via de Wesender API.", tools=[send_email], verbose=True, ) schrijf_taak = Task( description="Schrijf een HTML-welkomstmail voor {ontvanger}. Geef alleen de HTML terug.", expected_output="Volledige HTML-e-mail als string", agent=schrijver, ) verstuur_taak = Task( description="Verstuur de HTML-mail naar {ontvanger} met onderwerp 'Welkom bij ons platform'.", expected_output="Bevestiging dat de e-mail verstuurd is", agent=verzender, context=[schrijf_taak], ) crew = Crew(agents=[schrijver, verzender], tasks=[schrijf_taak, verstuur_taak]) result = crew.kickoff(inputs={ "ontvanger": "kees@voorbeeld.nl" }) print(result) ``` ## Veelgestelde vragen **Kan ik een reviewstap toevoegen voor het versturen?** Ja. Voeg een reviewer-agent toe tussen de schrijver en de verzender. Geef de reviewer-taak de schrijftaak als context. De reviewer past de HTML aan als dat nodig is, waarna de verzender de definitieve versie doorstuurt. **Hoe gebruik ik een ander taalmodel per agent?** Geef elke agent zijn eigen llm-parameter mee: Agent(llm=ChatOpenAI(model='gpt-4o'), ...). Je kunt de schrijver op een krachtig model zetten en de verzender op een sneller model, omdat die agent weinig generatieve intelligentie nodig heeft. **Wat kost het om CrewAI met OpenAI te gebruiken?** Kosten hangen af van het model en het aantal tokens. Gebruik gpt-4o-mini voor lage kosten tijdens ontwikkeling. Schakel over naar gpt-4o voor productie als de kwaliteit dat vereist. De Wesender API-kosten zijn afhankelijk van je abonnement. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/crewai - Marketingpagina: https://wesender.nl/ai/integraties/crewai - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Make + WeSender > Verbind Make-scenarios met de Wesender API via een HTTP-module en stuur automatisch e-mails vanuit elke trigger, zonder code. **Categorie:** workflow | **URL:** https://docs.wesender.nl/docs/integraties/make ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - Make-account (gratis of betaald plan) ## Integratiestappen ### Stap 1: Maak een nieuw Make-scenario Log in op make.com, klik op 'Create a new scenario' en voeg een trigger-module toe. Gebruik Webhook, Google Sheets, Airtable of een andere bron die past bij jouw situatie. ### Stap 2: Voeg een HTTP-module toe Klik op het plusje na je trigger, zoek op 'HTTP' en kies 'Make a request'. Vul de URL in, stel de methode in op POST en voeg de Authorization-header toe. ### Stap 3: Stel de request body in Klik op 'Body' en kies 'Raw'. Voer de JSON in en gebruik Make-variabelen ({{1.email}}) om velden dynamisch in te vullen vanuit je trigger. ### Stap 4: Test en activeer het scenario Klik op 'Run once' om het scenario te testen met echte data. Controleer of de e-mail aankomt. Activeer daarna het scenario zodat het automatisch draait bij elke nieuwe trigger. ## Volledig voorbeeld (make-http-module.json) ```json { "url": "https://api.wesender.nl/v1/emails", "method": "POST", "headers": [ { "name": "Authorization", "value": "Bearer {{WESENDER_API_KEY}}" }, { "name": "Content-Type", "value": "application/json" } ], "body": { "from": "noreply@jouwdomein.nl", "to": "{{1.email}}", "subject": "{{1.subject}}", "html": "{{1.html}}" } } ``` ## Veelgestelde vragen **Kan ik HTML-e-mails met Make-variabelen opbouwen?** Ja. Gebruik de Text Aggregator- of String-module om HTML dynamisch op te bouwen vanuit Make-variabelen. Zet het resultaat door als de html-waarde in de HTTP-module. Zo stuur je gepersonaliseerde e-mails op basis van formulierdata of databaserecords. **Hoe verwerk ik bounces terug in Make?** Voeg een Webhook-module toe als triggerpunt en stel de URL in als bezorgwebhook in het Wesender-dashboard. Elke bounce-, klacht- of bezorgingsevent triggert dan je scenario, zodat je de status kunt opslaan in Airtable, Google Sheets of je eigen database. **Hoeveel e-mails kan ik per scenario versturen?** Dat hangt af van je Make-plan (operaties per maand) en je Wesender-abonnement (e-mails per maand). Gebruik de iterator in Make om in bulk te versturen. Houd rekening met rate limits: Wesender accepteert maximaal 100 requests per seconde. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/make - Marketingpagina: https://wesender.nl/ai/integraties/make - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Zapier + WeSender > Verstuur automatisch e-mails via Wesender vanuit duizenden Zapier-apps met de ingebouwde Webhooks-actie. **Categorie:** workflow | **URL:** https://docs.wesender.nl/docs/integraties/zapier ## Vereisten - Wesender-account met geverifieerd verzenddomein - API-sleutel van Wesender (WESENDER_API_KEY) - Zapier-account (Starter-plan of hoger voor Webhooks) ## Integratiestappen ### Stap 1: Maak een nieuw Zap Log in op zapier.com, klik op 'Create Zap' en voeg een trigger toe. Kies een app zoals Google Forms, Typeform, HubSpot of Stripe als startpunt van je automatisering. ### Stap 2: Voeg 'Webhooks by Zapier' toe als actie Klik op het plusje, zoek op 'Webhooks by Zapier' en kies 'POST'. Dit is de actie die de Wesender API aanroept. ### Stap 3: Configureer het webhook-verzoek Vul de URL, headers en de payload in. Gebruik Zapier-velden (zoals Contact Email) om de e-mail dynamisch te personaliseren. ### Stap 4: Test en zet de Zap live Klik op 'Test action' om een testmail te versturen. Controleer of de e-mail aankomt. Schakel de Zap in zodat hij automatisch draait bij elke nieuwe trigger-event. ## Volledig voorbeeld (zapier-webhook-config.json) ```json { "url": "https://api.wesender.nl/v1/emails", "method": "POST", "headers": { "Authorization": "Bearer WESENDER_API_KEY", "Content-Type": "application/json" }, "data": { "from": "noreply@jouwdomein.nl", "to": "{{contact_email}}", "subject": "Bedankt voor je aanmelding", "html": "Hoi {{contact_first_name}}, welkom!
" } } ``` ## Veelgestelde vragen **Kan ik HTML-e-mails opbouwen in Zapier?** Ja. Gebruik een Formatter by Zapier-stap voor de Webhooks-actie om tekstvelden samen te voegen tot een HTML-string. Zo verwerk je dynamische inhoud, zoals de naam en het bestelnummer van een klant, in de HTML. **Hoe verwerk ik bezorgingsstatussen terug in Zapier?** Voeg een Catch Hook-trigger toe aan een apart Zap en stel de URL in als bezorgwebhook in het Wesender-dashboard. Elke bezorging-, bounce- of klachtevent triggert dit Zap, zodat je de status kunt opslaan in Airtable, Google Sheets of je CRM. **Werkt dit ook op het gratis Zapier-plan?** Webhooks by Zapier is alleen beschikbaar op betaalde Zapier-plannen (Starter of hoger). Op het gratis plan kun je Make als alternatief gebruiken: dat biedt webhook-integraties op het gratis plan. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/zapier - Marketingpagina: https://wesender.nl/ai/integraties/zapier - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Pydantic AI + WeSender > Type-veilige Python-agents met automatische validatie — stuur e-mail via Wesender als gevalideerde tool. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/pydantic-ai ## Vereisten - Python 3.11+ geïnstalleerd - Wesender-account met API-sleutel - pip install "pydantic-ai[openai]" wesender - Omgevingsvariabelen: WESENDER_API_KEY en OPENAI_API_KEY ## Integratiestappen ### Stap 1: Installeer Pydantic AI en de Wesender Python SDK Voeg de benodigde packages toe. Pydantic AI ondersteunt meerdere model-providers via een uniforme interface. ### Stap 2: Definieer de send_email-tool met type-annotaties Pydantic AI gebruikt Python-functies met type-annotaties voor automatische validatie van toolparameters. Decoreer de functie met @agent.tool_plain om hem als tool te registreren. ### Stap 3: Roep de agent aan De agent herkent automatisch wanneer send_email moet worden aangeroepen op basis van de gebruikersvraag. Pydantic AI valideert alle parameters vóór uitvoering. ### Stap 4: Verwerk het resultaat De agent geeft het resultaat van de tool terug als string. Sla het e-mail-ID op voor bezorgingscontrole via Wesender-webhooks. ## Volledig voorbeeld (pydantic_ai_email.py) ```python import asyncio import os from pydantic_ai import Agent from wesender import Wesender client = Wesender(api_key=os.environ["WESENDER_API_KEY"]) agent = Agent( model="openai:gpt-4o", system_prompt="Je bent een assistent die e-mails verstuurt via Wesender.", ) @agent.tool_plain async def send_email(to: str, subject: str, html: str) -> str: """Verstuur een e-mail via Wesender.""" result = client.emails.send( from_="noreply@jouwdomein.nl", to=to, subject=subject, html=html, ) return f"E-mail verzonden. ID: {result.id}" async def main(): response = await agent.run( "Stuur een welkomstmail naar jan@voorbeeld.nl " "met als onderwerp 'Welkom bij ons platform' " "en als inhoud een vriendelijke HTML-begroeting." ) print(response.data) if __name__ == "__main__": asyncio.run(main()) ``` ## Veelgestelde vragen **Welke model-providers werken met Pydantic AI?** Pydantic AI ondersteunt OpenAI, Anthropic, Google Gemini, Groq en Mistral via een uniforme interface. Je wisselt van provider door de model-parameter aan te passen, bijv. van 'openai:gpt-4o' naar 'anthropic:claude-sonnet-4-5'. **Hoe valideer ik e-mailadressen vóór het versturen?** Gebruik Pydantic-modellen als toolparameters. Vervang losse string-annotaties door een dataclass met EmailStr uit pydantic[email]. Pydantic AI valideert de invoer automatisch voordat de tool wordt aangeroepen. **Kan ik meerdere e-mails in één agent-run versturen?** Ja. De agent roept send_email herhaaldelijk aan als de instructie dat vereist. Elke aanroep retourneert een uniek e-mail-ID. Je kunt ook een batchfunctie definiëren die een lijst adressen accepteert. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/pydantic-ai - Marketingpagina: https://wesender.nl/ai/integraties/pydantic-ai - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Mastra + WeSender > TypeScript-agentframework met Zod-validatie — definieer send_email als eerste-klasse Mastra-tool. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/mastra ## Vereisten - Node.js 20+ en TypeScript 5+ - Wesender-account met API-sleutel - npm install @mastra/core @wesender/node zod - Omgevingsvariabelen: WESENDER_API_KEY en OPENAI_API_KEY ## Integratiestappen ### Stap 1: Installeer Mastra en de Wesender Node SDK Voeg de benodigde packages toe. Mastra biedt een TypeScript-native interface voor productie-agents. ### Stap 2: Definieer de send_email-tool met Zod-schema Mastra-tools zijn type-safe met Zod-schemadefinities. Parameters worden automatisch gevalideerd voordat de tool wordt uitgevoerd. ### Stap 3: Maak de agent aan Koppel de tool aan een Mastra-agent. De agent bepaalt op basis van de instructie wanneer send_email wordt aangeroepen. ### Stap 4: Voer de agent uit Roep de agent aan met een gebruikersinstructie. Het resultaat bevat het antwoord van de agent plus de tool-aanroepen die zijn uitgevoerd. ## Volledig voorbeeld (mastra-email-agent.ts) ```typescript import { Agent, createTool } from "@mastra/core" import { Wesender } from "@wesender/node" import { z } from "zod" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const sendEmailTool = createTool({ id: "send_email", description: "Verstuur een e-mail via Wesender", inputSchema: z.object({ to: z.string().email(), subject: z.string(), html: z.string(), }), execute: async ({ context }) => { const result = await emailClient.emails.send({ from: "noreply@jouwdomein.nl", to: context.to, subject: context.subject, html: context.html, }) return { success: true, id: result.id } }, }) const emailAgent = new Agent({ name: "email-agent", instructions: "Je bent een assistent die e-mails verstuurt via Wesender. " + "Gebruik send_email zodra de gebruiker dat vraagt.", model: { provider: "OPEN_AI", name: "gpt-4o", toolChoice: "auto" }, tools: { sendEmailTool }, }) const response = await emailAgent.generate([ { role: "user", content: "Stuur een welkomstmail naar jan@voorbeeld.nl." }, ]) console.log(response.text) ``` ## Veelgestelde vragen **Welke LLM-providers ondersteunt Mastra?** Mastra ondersteunt OpenAI, Anthropic, Google Gemini en andere providers via een gestandaardiseerde interface. Je wisselt van provider door model.provider aan te passen, zonder de toollogica te hoeven wijzigen. **Werkt Mastra met een bestaand Express- of Fastify-project?** Ja. Mastra is framework-agnostisch. Importeer de agent en roep generate() aan vanuit elke Node.js-server of serverless functie, zoals een Next.js API-route of een Hono-endpoint. **Hoe log ik e-mail-ID's voor bezorgingscontrole?** Het tool-resultaat bevat { success: true, id: result.id }. Sla dit op in je eigen database of stuur het terug naar de gebruiker. Combineer met Wesender-webhooks voor realtime bezorgingsstatussen. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/mastra - Marketingpagina: https://wesender.nl/ai/integraties/mastra - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Google Gemini + WeSender > Gemini Function Calling in TypeScript — laat je Gemini-model e-mail versturen via Wesender. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/gemini ## Vereisten - Node.js 20+ en TypeScript - Wesender-account met API-sleutel - npm install @google/generative-ai @wesender/node - Omgevingsvariabelen: WESENDER_API_KEY en GEMINI_API_KEY ## Integratiestappen ### Stap 1: Installeer de Google Generative AI SDK en Wesender Voeg de officiële Google SDK en de Wesender Node SDK toe aan je project. ### Stap 2: Definieer send_email als Gemini-functie Gemini Function Calling gebruikt een JSON-schema om beschikbare functies te beschrijven. Definieer de parameters zodat Gemini weet hoe de functie aan te roepen. ### Stap 3: Voer de function call uit via Wesender Wanneer Gemini een functionCall teruggeeft, voer je de logica uit met de Wesender Node SDK en stuur je het resultaat terug in de conversatie. ### Stap 4: Bouw de conversatielus Stuur berichten naar Gemini, verwerk function calls en herhaal totdat het model een definitief tekstantwoord geeft. ## Volledig voorbeeld (gemini-email-agent.ts) ```typescript import { GoogleGenerativeAI } from "@google/generative-ai" import { Wesender } from "@wesender/node" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!) const model = genAI.getGenerativeModel({ model: "gemini-1.5-pro", tools: [{ functionDeclarations: [{ name: "send_email", description: "Verstuur een e-mail via Wesender", parameters: { type: "OBJECT", properties: { to: { type: "STRING" }, subject: { type: "STRING" }, html: { type: "STRING" }, }, required: ["to", "subject", "html"], }, }], }], }) async function runAgent(prompt: string) { const chat = model.startChat() let result = await chat.sendMessage(prompt) while (result.response.functionCalls()?.length) { const call = result.response.functionCalls()![0] const args = call.args as { to: string; subject: string; html: string } const emailResult = await emailClient.emails.send({ from: "noreply@jouwdomein.nl", to: args.to, subject: args.subject, html: args.html, }) result = await chat.sendMessage([{ functionResponse: { name: call.name, response: { success: true, id: emailResult.id }, }, }]) } return result.response.text() } console.log(await runAgent( "Stuur een welkomstmail naar jan@voorbeeld.nl met een vriendelijke begroeting." )) ``` ## Veelgestelde vragen **Welke Gemini-modellen ondersteunen Function Calling?** Gemini 1.5 Pro en Gemini 1.5 Flash ondersteunen beiden Function Calling. Flash is goedkoper en sneller; Pro is beter in complexe redeneringen. Beide werken identiek met de bovenstaande code. **Kan Gemini meerdere functies tegelijk aanroepen?** Ja, Gemini kan parallelle function calls teruggeven. Itereer dan over result.response.functionCalls() volledig en verwerk alle resultaten gelijktijdig met Promise.all voor betere prestaties. **Hoe beperk ik welke functies Gemini mag aanroepen?** Gebruik toolConfig in de modelconfiguratie met mode: 'ANY' en een allowedFunctionNames-lijst. Zo beperk je Gemini tot uitsluitend send_email, ook als je meer functies definieert. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/gemini - Marketingpagina: https://wesender.nl/ai/integraties/gemini - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # LlamaIndex + WeSender > Combineer RAG en e-mailbezorging in één LlamaIndex-agent — verstuur e-mail via Wesender als FunctionTool. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/llamaindex ## Vereisten - Python 3.11+ en pip - Wesender-account met API-sleutel - pip install llama-index wesender openai - Omgevingsvariabelen: WESENDER_API_KEY en OPENAI_API_KEY ## Integratiestappen ### Stap 1: Installeer LlamaIndex en de Wesender Python SDK Voeg de benodigde packages toe. LlamaIndex vereist ook de OpenAI-bibliotheek voor de standaard LLM-backend. ### Stap 2: Definieer send_email als LlamaIndex FunctionTool LlamaIndex-agents gebruiken FunctionTool om Python-functies beschikbaar te maken als tool-aanroepen. De docstring wordt gebruikt als beschrijving voor het LLM. ### Stap 3: Maak een ReActAgent aan met de e-mailtool Combineer de e-mailtool met andere LlamaIndex-tools, zoals een QueryEngine voor documentretrieval. De agent beslist zelf welke tool hij wanneer inzet. ### Stap 4: Roep de agent aan Geef de agent een instructie in natuurlijke taal. De ReActAgent redeneert stap voor stap en roept send_email aan wanneer nodig. ## Volledig voorbeeld (llamaindex_email_agent.py) ```python import os from llama_index.core.tools import FunctionTool from llama_index.core.agent import ReActAgent from llama_index.llms.openai import OpenAI from wesender import Wesender client = Wesender(api_key=os.environ["WESENDER_API_KEY"]) def send_email(to: str, subject: str, html: str) -> str: """ Verstuur een e-mail via Wesender. Args: to: E-mailadres van de ontvanger. subject: Onderwerpregel van de e-mail. html: HTML-inhoud van de e-mail. """ result = client.emails.send( from_="noreply@jouwdomein.nl", to=to, subject=subject, html=html, ) return f"E-mail verzonden. ID: {result.id}" email_tool = FunctionTool.from_defaults(fn=send_email) agent = ReActAgent.from_tools( tools=[email_tool], llm=OpenAI(model="gpt-4o"), verbose=True, ) response = agent.chat( "Stuur een welkomstmail naar jan@voorbeeld.nl " "met onderwerp 'Welkom bij ons platform'." ) print(response.response) ``` ## Veelgestelde vragen **Kan ik de e-mailtool combineren met een documentindex?** Ja. Voeg naast email_tool ook een QueryEngineTool toe die verbonden is met je VectorStoreIndex. De agent kan eerst documenten raadplegen en daarna een samenvatting per e-mail versturen. **Welke LLM-backends ondersteunt LlamaIndex?** LlamaIndex ondersteunt OpenAI, Anthropic, Mistral, HuggingFace en meer via pluggable LLM-integraties. Vervang OpenAI(model=...) door bijv. Anthropic(model='claude-sonnet-4-5') na installatie van llama-index-llms-anthropic. **Hoe gebruik ik de async-variant voor hoge throughput?** Gebruik achat() in plaats van chat() voor asynchroon gebruik: response = await agent.achat(...). Combineer met asyncio.gather() om meerdere agents tegelijk te draaien. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/llamaindex - Marketingpagina: https://wesender.nl/ai/integraties/llamaindex - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Mistral AI + WeSender > Mistral Function Calling in TypeScript — stuur e-mail via Wesender vanuit een Europees AI-model. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/mistral ## Vereisten - Node.js 20+ en TypeScript - Wesender-account met API-sleutel - npm install @mistralai/mistralai @wesender/node - Omgevingsvariabelen: WESENDER_API_KEY en MISTRAL_API_KEY ## Integratiestappen ### Stap 1: Installeer de Mistral SDK en Wesender Voeg de officiële Mistral TypeScript SDK en de Wesender Node SDK toe aan je project. ### Stap 2: Definieer send_email als Mistral-tool Mistral Function Calling gebruikt een JSON-schema vergelijkbaar met OpenAI. Definieer de tool met naam, beschrijving en parameterspecificatie. ### Stap 3: Voer de tool uit via Wesender Verwerk de tool call die Mistral teruggeeft en stuur het resultaat terug als tool-bericht in de conversatie. ### Stap 4: Bouw de agent-lus Stuur het bericht naar Mistral, verwerk eventuele tool calls en herhaal totdat Mistral een definitief antwoord geeft. ## Volledig voorbeeld (mistral-email-agent.ts) ```typescript import Mistral from "@mistralai/mistralai" import { Wesender } from "@wesender/node" const mistral = new Mistral({ apiKey: process.env.MISTRAL_API_KEY! }) const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const tools = [{ type: "function" as const, function: { name: "send_email", description: "Verstuur een e-mail via Wesender", parameters: { type: "object", properties: { to: { type: "string" }, subject: { type: "string" }, html: { type: "string" }, }, required: ["to", "subject", "html"], }, }, }] async function runAgent(userMessage: string) { const messages: any[] = [{ role: "user", content: userMessage }] let response = await mistral.chat.complete({ model: "mistral-large-latest", messages, tools, toolChoice: "auto", }) while (response.choices?.[0].finishReason === "tool_calls") { const toolCalls = response.choices[0].message.toolCalls! messages.push(response.choices[0].message) for (const call of toolCalls) { const args = JSON.parse(call.function.arguments as string) const result = await emailClient.emails.send({ from: "noreply@jouwdomein.nl", to: args.to, subject: args.subject, html: args.html, }) messages.push({ role: "tool", toolCallId: call.id, content: JSON.stringify({ success: true, id: result.id }), }) } response = await mistral.chat.complete({ model: "mistral-large-latest", messages, tools }) } return response.choices?.[0].message.content } console.log(await runAgent( "Stuur een welkomstmail naar jan@voorbeeld.nl met als onderwerp 'Welkom'." )) ``` ## Veelgestelde vragen **Welke Mistral-modellen ondersteunen function calling?** Mistral Large, Mistral Medium en Mistral Small ondersteunen allen function calling. Voor productie raden we mistral-large-latest aan vanwege de hogere nauwkeurigheid bij tool-selectie. **Zijn Mistral-inferentie en Wesender-data beide Europees?** Mistral verwerkt inferentie op servers in Europa. Wesender verwerkt e-mailbezorging in Europese datacenters. Je AI-workflow blijft volledig binnen de EER. **Hoe verwerk ik meerdere parallelle tool calls?** Mistral kan meerdere tool calls in één response teruggeven. Gebruik Promise.all om alle calls gelijktijdig te verwerken: await Promise.all(toolCalls.map(call => executeTool(...))). Voeg alle resultaten als tool-berichten toe vóór de volgende request. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/mistral - Marketingpagina: https://wesender.nl/ai/integraties/mistral - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Dify + WeSender > Bouw AI-workflows zonder code — koppel Wesender als HTTP-actieblok in je Dify-workflow. **Categorie:** workflow | **URL:** https://docs.wesender.nl/docs/integraties/dify ## Vereisten - Dify-account (cloud op dify.ai of self-hosted via Docker) - Wesender-account met API-sleutel - Een bestaande of nieuwe Dify-workflow - Geen programmeerkennis vereist ## Integratiestappen ### Stap 1: Maak een nieuwe Dify-workflow aan Log in op Dify en navigeer naar Studio → Workflow → Nieuw aanmaken. Kies het type Workflow (niet Chatflow). Geef de workflow een naam, bijv. 'Welkomstmail verzenden'. ### Stap 2: Configureer het Start-blok met invoervariabelen Klik op het Start-blok en voeg invoervariabelen toe: to_email (tekst) en naam (tekst). Deze worden ingevuld bij het starten van de workflow. ### Stap 3: Voeg een LLM-blok toe voor de e-mailinhoud Voeg een LLM-blok toe om een gepersonaliseerde e-mailtekst te genereren. Verbind het Start-blok als invoer en gebruik variabelen via Dify-expressies. ### Stap 4: Voeg een HTTP-verzoekblok toe voor Wesender Voeg een HTTP-verzoek-blok toe. Stel methode, URL, headers en body in om de Wesender API aan te roepen. Verwijs naar LLM-output via de Dify-expressie {{#llm.text#}}. ### Stap 5: Sla de API-sleutel op als omgevingsvariabele Navigeer naar Instellingen → Omgevingsvariabelen en voeg WESENDER_API_KEY toe met je Wesender API-sleutel. Verwijs er in het HTTP-blok naar via {{WESENDER_API_KEY}} zodat de sleutel nooit zichtbaar is in de workflow-configuratie. ### Stap 6: Test en publiceer de workflow Klik op Uitvoeren in de workflow-editor, vul testwaarden in voor to_email en naam, en controleer of de e-mail aankomt. Publiceer de workflow: Dify genereert een API-eindpunt waarmee je de workflow vanuit externe systemen kunt triggeren. ## Volledig voorbeeld (dify-workflow-config.json) ```json { "workflow_name": "Welkomstmail verzenden", "nodes": [ { "type": "start", "variables": [ { "key": "to_email", "type": "string", "label": "Ontvanger e-mailadres" }, { "key": "naam", "type": "string", "label": "Naam ontvanger" } ] }, { "type": "llm", "model": "gpt-4o", "system_prompt": "Je bent een assistent die welkomstmails schrijft in HTML.", "user_prompt": "Schrijf een welkomstmail in HTML voor {{#start.naam#}}." }, { "type": "http_request", "method": "POST", "url": "https://api.wesender.nl/v1/emails", "headers": { "Authorization": "Bearer {{WESENDER_API_KEY}}", "Content-Type": "application/json" }, "body": { "from": "noreply@jouwdomein.nl", "to": "{{#start.to_email#}}", "subject": "Welkom bij ons platform", "html": "{{#llm.text#}}" } } ] } ``` ## Veelgestelde vragen **Kan ik Dify self-hosten voor volledige datacontrole?** Ja. Dify is open-source en kan via Docker worden gehost op je eigen server. Combineer dit met de Wesender API voor een volledig Europese, self-hosted AI-e-mailoplossing. **Hoe trigger ik de workflow vanuit een extern systeem?** Na publicatie genereert Dify een API-eindpunt. Stuur een POST-verzoek naar dit eindpunt met je inputs als JSON-body en de Dify API-key als Bearer-token. Zo koppel je de workflow aan je CRM, webshop of andere systemen. **Kan ik bezorgingsstatussen terugkrijgen in Dify?** Voeg een tweede HTTP-blok toe om een Wesender-webhook te registreren, of gebruik een externe integratie zoals Make of Zapier om bezorgingsevents te ontvangen en terug te koppelen aan een Dify-workflow via de Run API. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/dify - Marketingpagina: https://wesender.nl/ai/integraties/dify - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # OpenAI Agents SDK + WeSender > De officiële OpenAI Agents SDK met ingebouwde tool-lus — voeg send_email toe en de agent mailt zelfstandig. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/openai-agents-sdk ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - OPENAI_API_KEY ingesteld als omgevingsvariabele - Node.js 18 of nieuwer - npm install @openai/agents @wesender/node zod ## Integratiestappen ### Stap 1: Installeer de pakketten Voeg de OpenAI Agents SDK, de WeSender Node SDK en Zod toe aan je project. ### Stap 2: Definieer de e-mailtool Maak send_email aan als een Agents SDK-tool met een Zod-schema. De execute-functie verstuurt de mail via WeSender en geeft het e-mail-ID terug. ### Stap 3: Maak de agent aan en start hem Maak een agent met de e-mailtool en start hem via run(). De SDK handelt de tool-lus automatisch af: aanroepen, uitvoeren, doorgaan. ## Volledig voorbeeld (src/agent.ts) ```typescript import { Agent, run, tool } from "@openai/agents" import { z } from "zod" import { Wesender } from "@wesender/node" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const sendEmail = tool({ name: "send_email", description: "Verstuur een transactionele e-mail via WeSender", parameters: z.object({ to: z.string(), subject: z.string(), html: z.string(), }), execute: async ({ to, subject, html }) => { const result = await emailClient.emails.send({ from: "agent@jouwdomein.nl", to, subject, html, }) return "E-mail verstuurd, id: " + result.id }, }) const agent = new Agent({ name: "Mailagent", instructions: "Je verstuurt transactionele e-mails namens de gebruiker.", tools: [sendEmail], }) const result = await run(agent, "Mail een welkomstbericht naar nieuwe@klant.nl") console.log(result.finalOutput) ``` ## Veelgestelde vragen **Kan de agent meerdere tools combineren?** Ja. Voeg extra tools toe aan de tools-array. De agent kiest zelf welke hij nodig heeft op basis van de instructie en de context van het gesprek. **Werkt dit ook met handoffs naar andere agents?** Ja. De Agents SDK ondersteunt handoffs tussen agents. Geef de e-mailtool aan de agent die berichten moet versturen en gebruik handoffs voor de overige taken. **Hoe beperk ik wat de agent mag doen?** Wees specifiek in de instructies en voeg een goedkeuringsstap in voor onomkeerbare acties. Je kunt ook de output van de agent eerst tonen aan de gebruiker voordat je de tool-aanroep uitvoert. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/openai-agents-sdk - Marketingpagina: https://wesender.nl/ai/integraties/openai-agents-sdk - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # OpenAI Responses API + WeSender > De opvolger van de Assistants API — definieer send_email als tool en het model bepaalt wanneer er gemaild wordt. **Categorie:** provider | **URL:** https://docs.wesender.nl/docs/integraties/openai-responses ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - OPENAI_API_KEY ingesteld als omgevingsvariabele - Node.js 18 of nieuwer - npm install openai @wesender/node ## Integratiestappen ### Stap 1: Installeer de pakketten Voeg de officiële OpenAI Node SDK en de WeSender Node SDK toe aan je project. ### Stap 2: Beschrijf de tool als JSON-schema Definieer send_email als een functie-tool met een JSON-schema. De Responses API gebruikt dit schema om te bepalen wanneer en met welke argumenten de tool aangeroepen wordt. ### Stap 3: Roep de Responses API aan Stuur een instructie naar het model. Als het model send_email wil aanroepen, geeft het een function_call-item terug in de output-array. ### Stap 4: Voer de toolaanroep uit Loop door de output en voer elke function_call uit met de WeSender Node SDK. ## Volledig voorbeeld (src/responses.ts) ```typescript import OpenAI from "openai" import { Wesender } from "@wesender/node" const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! }) const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const tools = [ { type: "function" as const, name: "send_email", description: "Verstuur een transactionele e-mail via WeSender", parameters: { type: "object", properties: { to: { type: "string" }, subject: { type: "string" }, html: { type: "string" }, }, required: ["to", "subject", "html"], additionalProperties: false, }, }, ] async function run(prompt: string) { const response = await openai.responses.create({ model: "gpt-4o", input: prompt, tools, }) for (const item of response.output) { if (item.type === "function_call" && item.name === "send_email") { const args = JSON.parse(item.arguments) const result = await emailClient.emails.send({ from: "assistent@jouwdomein.nl", ...args, }) console.log("E-mail verstuurd, id: " + result.id) } } } run("Mail een welkomstbericht naar nieuwe@klant.nl") ``` ## Veelgestelde vragen **Waarom de Responses API en niet de Assistants API?** OpenAI sluit de Assistants API op 26 augustus 2026. De Responses API is de aanbevolen opvolger voor nieuwe projecten en de plek waar nieuwe modellen als eerste beschikbaar komen. **Moet ik het toolresultaat terugsturen voor een vervolggesprek?** Ja. Stuur het toolresultaat terug in een volgende aanroep via het previous_response_id-veld, zodat het model de context van het gesprek behoudt. **Werkt dit met alle OpenAI-modellen?** Met elk model dat tool calling ondersteunt op de Responses API. OpenAI brengt nieuwe modellen exclusief uit op deze API. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/openai-responses - Marketingpagina: https://wesender.nl/ai/integraties/openai-responses - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Google ADK + WeSender > Bouw een Gemini-agent met de Agent Development Kit van Google en geef hem een e-mailtool via WeSender. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/google-adk ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - Een Gemini API-sleutel via Google AI Studio - Python 3.10 of nieuwer - pip install google-adk wesender ## Integratiestappen ### Stap 1: Installeer de pakketten Voeg de Google ADK en de WeSender Python SDK toe aan je project. ### Stap 2: Definieer de tool en maak de agent Schrijf send_email als gewone Python-functie. De ADK gebruikt de docstring en type-annotaties om het model te vertellen wat de tool doet. ### Stap 3: Start de agent via de ADK Runner Maak een Runner-instantie en roep de agent aan met een sessie. De ADK handelt de tool-aanroepen automatisch af. ## Volledig voorbeeld (agent.py) ```python import asyncio import os from google.adk.agents import Agent from google.adk.runners import Runner from google.adk.sessions import InMemorySessionService from wesender import Wesender client = Wesender(api_key=os.environ["WESENDER_API_KEY"]) def send_email(to: str, subject: str, html: str) -> dict: """Verstuur een transactionele e-mail via WeSender.""" result = client.emails.send( from_="agent@jouwdomein.nl", to=to, subject=subject, html=html, ) return {"status": "verstuurd", "id": result.id} root_agent = Agent( name="mailagent", model="gemini-2.5-flash", instruction="Je verstuurt transactionele e-mails namens de gebruiker.", tools=[send_email], ) async def main(): sessions = InMemorySessionService() runner = Runner(agent=root_agent, session_service=sessions) session = await sessions.create_session() response = await runner.run( session_id=session.id, message="Mail een welkomstbericht naar nieuwe@klant.nl", ) print(response.text) if __name__ == "__main__": asyncio.run(main()) ``` ## Veelgestelde vragen **Kan ik dit combineren met andere ADK-tools?** Ja. Voeg meer functies toe aan de tools-lijst van de agent. De ADK bepaalt op basis van de instructie welke tool wanneer ingezet wordt. **Werkt dit ook met sub-agents?** Ja. De ADK ondersteunt hiërarchische agents. Geef de e-mailtool aan de sub-agent die berichten moet versturen en laat de root-agent de taakverdeling regelen. **Welke Gemini-modellen kan ik gebruiken?** De ADK werkt met de Gemini-modellenfamilie. Pas de modelnaam aan in de Agent-aanroep, zoals gemini-2.5-pro, om een ander model te kiezen. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/google-adk - Marketingpagina: https://wesender.nl/ai/integraties/google-adk - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # AutoGen + WeSender > Registreer WeSender als tool in een multi-agent AutoGen-gesprek en laat agents e-mails versturen tijdens hun samenwerking. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/autogen ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - Een modelsleutel voor het LLM naar keuze - Python 3.10 of nieuwer - pip install autogen wesender ## Integratiestappen ### Stap 1: Installeer de pakketten Voeg AutoGen (AG2) en de WeSender Python SDK toe aan je project. ### Stap 2: Definieer de tool en maak de agents Schrijf send_email als Python-functie. Maak een assistant-agent die beslist en een executor-agent die uitvoert. Zo scheid je beslissen en handelen. ### Stap 3: Registreer de tool Koppel send_email aan de juiste agents. De assistant bepaalt wanneer de tool nodig is, de executor voert hem daadwerkelijk uit. ### Stap 4: Start het gesprek De executor opent het gesprek. De agents wisselen berichten uit totdat de taak afgerond is en de e-mail verstuurd. ## Volledig voorbeeld (main.py) ```python import os from autogen import ConversableAgent, register_function from wesender import Wesender client = Wesender(api_key=os.environ["WESENDER_API_KEY"]) def send_email(to: str, subject: str, html: str) -> str: """Verstuur een transactionele e-mail via WeSender.""" result = client.emails.send( from_="agent@jouwdomein.nl", to=to, subject=subject, html=html, ) return f"E-mail verstuurd, id: {result.id}" assistant = ConversableAgent( name="assistant", llm_config={"model": "gpt-4o"}, ) executor = ConversableAgent( name="executor", human_input_mode="NEVER", ) register_function( send_email, caller=assistant, executor=executor, description="Verstuur een transactionele e-mail via WeSender", ) executor.initiate_chat( assistant, message="Mail een welkomstbericht naar nieuwe@klant.nl", ) ``` ## Veelgestelde vragen **Welke agent verstuurt de mail?** De executor voert de tool uit nadat de assistant hem heeft aangewezen. Zo scheid je beslissen en uitvoeren, wat de controleerbaarheid van je multi-agent systeem vergroot. **Werkt dit ook met groepsgesprekken?** Ja. Registreer de tool bij de juiste agents in je groepsgesprek. De GroupChatManager stuurt de beurt naar de agent die de e-mail moet versturen. **Kan ik een mens laten goedkeuren?** Ja. Zet human_input_mode op 'ALWAYS' of 'TERMINATE' bij de executor om bevestiging te vragen voordat de tool wordt uitgevoerd. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/autogen - Marketingpagina: https://wesender.nl/ai/integraties/autogen - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Semantic Kernel + WeSender > Voeg WeSender toe als KernelFunction-plugin in je .NET-agent en laat Semantic Kernel de REST API aanroepen. **Categorie:** agent | **URL:** https://docs.wesender.nl/docs/integraties/semantic-kernel ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - WESENDER_API_KEY en een OpenAI- of Azure OpenAI-sleutel - .NET 8 of nieuwer - dotnet add package Microsoft.SemanticKernel ## Integratiestappen ### Stap 1: Installeer het pakket Voeg de Semantic Kernel NuGet toe aan je .NET-project. ### Stap 2: Maak de e-mailplugin Definieer een klasse met een KernelFunction-methode. WeSender heeft geen .NET SDK, dus je roept de REST API aan via HttpClient. ### Stap 3: Registreer de plugin en draai de kernel Bouw de kernel op, voeg de EmailPlugin toe en schakel automatisch function calling in. De kernel roept de plugin zelf aan op het juiste moment. ## Volledig voorbeeld (Program.cs) ```csharp using System.ComponentModel; using System.Net.Http.Json; using Microsoft.SemanticKernel; // Plugin public class EmailPlugin { private static readonly HttpClient http = new(); [KernelFunction("send_email")] [Description("Verstuur een transactionele e-mail via WeSender")] public async TaskHoi {{trigger.naam}}, bedankt voor je aanmelding.
" } } ``` ## Veelgestelde vragen **Heb ik programmeerkennis nodig?** Nee. Je configureert een HTTP-piece via de visuele editor en vult de JSON-body in. Geen code vereist. **Waarom Activepieces in plaats van Make of Zapier?** Activepieces is open-source en zelf te hosten, handig als je alles binnen je eigen EU-infrastructuur wilt houden zonder afhankelijkheid van externe SaaS-providers. **Kan ik per trigger andere ontvangers mailen?** Ja. Gebruik triggervelden in het to-veld van de body, zoals {{trigger.email}}, om dynamisch de ontvanger in te stellen op basis van de binnenkomende data. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/activepieces - Marketingpagina: https://wesender.nl/ai/integraties/activepieces - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Pipedream + WeSender > Voeg WeSender toe als Node-codestap in je Pipedream-workflow en verstuur e-mails vanuit elke trigger. **Categorie:** workflow | **URL:** https://docs.wesender.nl/docs/integraties/pipedream ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - WESENDER_API_KEY opgeslagen als environment variable in Pipedream - Een Pipedream-account ## Integratiestappen ### Stap 1: Sla de API-sleutel op als omgevingsvariabele Navigeer in Pipedream naar Settings > Environment Variables en voeg WESENDER_API_KEY toe. Zo is de sleutel nooit zichtbaar in je workflowcode. ### Stap 2: Maak een workflow met een trigger Maak een nieuwe workflow en kies de trigger die de e-mail moet veroorzaken, zoals een HTTP-trigger of een event van een externe dienst. ### Stap 3: Voeg een Node-codestap toe Klik op het plusje en kies Run Node.js code. Plak de onderstaande stap in de editor en pas de triggervelden aan op je eigen situatie. ### Stap 4: Test en publiceer de workflow Klik op Test om een testmail te versturen. Controleer of het e-mail-ID wordt teruggegeven en publiceer de workflow daarna. ## Volledig voorbeeld (send-email.js) ```javascript import { Wesender } from "@wesender/node" export default defineComponent({ async run({ steps }) { const client = new Wesender(process.env.WESENDER_API_KEY) // Pas dit aan op je triggergegevens const to = steps.trigger.event.email const subject = steps.trigger.event.subject ?? "Bedankt voor je aanmelding" const html = "Hoi, bedankt voor je aanmelding.
" const result = await client.emails.send({ from: "workflow@jouwdomein.nl", to, subject, html }) return { id: result.id } }, }) ``` ## Veelgestelde vragen **Code of no-code?** Pipedream is low-code. Een korte Node-stap geeft je de meeste controle en flexibiliteit. Wil je geen code schrijven, dan is een HTTP Request-stap ook mogelijk. **Waar sla ik mijn API-sleutel op?** Als environment variable in Pipedream, zodat hij niet zichtbaar is in je workflowcode en niet in versiebeheer terechtkomt. **Kan ik triggervelden gebruiken in de e-mailbody?** Ja. Lees ze uit via steps.trigger.event in je code. Zo verwerk je naam, bestelnummer of andere gegevens van de trigger direct in de e-mail. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/pipedream - Marketingpagina: https://wesender.nl/ai/integraties/pipedream - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # CopilotKit + WeSender > Geef de copilot in je React-app een e-mailactie — de sleutel blijft op de server, de actie in je component. **Categorie:** assistent | **URL:** https://docs.wesender.nl/docs/integraties/copilotkit ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - WESENDER_API_KEY alleen op de server, nooit in de browser - Een React-app met CopilotKit opgezet - npm install @wesender/node ## Integratiestappen ### Stap 1: Maak een server-route voor e-mail Houd je WeSender API-sleutel op de server. Maak een serverroute die de browser aanroept, nooit WeSender rechtstreeks vanuit de client. ### Stap 2: Definieer de copilot-actie Voeg useCopilotAction toe in een component binnen de CopilotKit-provider. De handler roept je eigen serverroute aan, zodat de API-sleutel nooit de browser bereikt. ### Stap 3: Voeg de CopilotKit UI toe aan je app Omsluit je app met een CopilotKitProvider en voeg een CopilotSidebar of CopilotPopup toe zodat gebruikers de copilot kunnen aanspreken. ## Volledig voorbeeld (app/api/send-email/route.ts) ```typescript import { Wesender } from "@wesender/node" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) export async function POST(req: Request) { const { to, subject, html } = await req.json() const result = await emailClient.emails.send({ from: "app@jouwdomein.nl", to, subject, html, }) return Response.json({ id: result.id }) } // Gebruik in je component (binnen CopilotKitProvider): // // import { useCopilotAction } from "@copilotkit/react-core" // // useCopilotAction({ // name: "send_email", // description: "Verstuur een transactionele e-mail via WeSender", // parameters: [ // { name: "to", type: "string" }, // { name: "subject", type: "string" }, // { name: "html", type: "string" }, // ], // handler: async ({ to, subject, html }) => { // const res = await fetch("/api/send-email", { // method: "POST", headers: { "Content-Type": "application/json" }, // body: JSON.stringify({ to, subject, html }), // }) // return "E-mail verstuurd, id: " + (await res.json()).id // }, // }) ``` ## Veelgestelde vragen **Mag mijn API-sleutel in de browser staan?** Nee. Houd de WeSender API-sleutel altijd op de server en laat de browser je eigen serverroute aanroepen. Zo is de sleutel nooit zichtbaar in je frontend-code of de browser-devtools. **Kan de gebruiker de mail eerst bekijken?** Ja. Toon een concept in de copilot met een bevestigingsinteractie en verstuur pas na goedkeuring. CopilotKit ondersteunt dit standaard voor onomkeerbare acties. **Werkt dit met elke React-app?** Ja, zolang je een CopilotKitProvider rond je app hebt en de actie wordt gedefinieerd in een component die daarbinnen valt. ## Links - Technische documentatie: https://docs.wesender.nl/docs/integraties/copilotkit - Marketingpagina: https://wesender.nl/ai/integraties/copilotkit - API-referentie: https://docs.wesender.nl/docs/api-reference/emails --- # Ollama + WeSender > Lokaal model, betrouwbare bezorging — laat Ollama een send_email tool aanroepen en WeSender verstuurt vanuit de EU. **Categorie:** provider | **URL:** https://docs.wesender.nl/docs/integraties/ollama ## Vereisten - WeSender-account met geverifieerd domein en API-sleutel - Ollama lokaal geinstalleerd met een tool-compatibel model (bijv. llama3.1) - Node.js 18 of nieuwer - npm install ollama @wesender/node ## Integratiestappen ### Stap 1: Installeer de pakketten Voeg de Ollama JavaScript-client en de WeSender Node SDK toe aan je project. Zorg dat Ollama lokaal draait en een model heeft geladen. ### Stap 2: Roep het lokale model aan met de tool Stuur een verzoek naar je lokale Ollama-instantie met de tool-definitie. Het model geeft een function_call terug als het send_email wil aanroepen. ### Stap 3: Voer de toolaanroep uit Controleer of het model een function_call heeft teruggegeven en verstuur de e-mail via WeSender. ## Volledig voorbeeld (src/ollama.ts) ```typescript import ollama from "ollama" import { Wesender } from "@wesender/node" const emailClient = new Wesender(process.env.WESENDER_API_KEY!) const response = await ollama.chat({ model: "llama3.1", messages: [{ role: "user", content: "Mail een welkomstbericht naar nieuwe@klant.nl" }], tools: [{ type: "function", function: { name: "send_email", description: "Verstuur een transactionele e-mail via WeSender", parameters: { type: "object", properties: { to: { type: "string" }, subject: { type: "string" }, html: { type: "string" }, }, required: ["to", "subject", "html"], }, }, }], }) const call = response.message.tool_calls?.[0] if (call?.function.name === "send_email") { const { to, subject, html } = call.function.arguments as RecordHoi ${naam}, je account is aangemaakt.
`, }) return result.id } async sendPasswordReset(to: string, resetUrl: string): PromiseHoi!
" }, }) ``` ## API-key opslaan Sla `WESENDER_API_KEY` op als Supabase-secret via het dashboard of de CLI, nooit in de clientcode. --- # Bolt.new Integreer Wesender in een Bolt.new-applicatie via een server-side API-route. ## Aanpak Bolt genereert full-stack webapplicaties. Maak een server-side API-route zodat de API-key nooit in de browser terechtkomt. ## API-route (Remix) ```typescript // app/routes/api.send-email.ts import type { ActionFunctionArgs } from "@remix-run/node" import { json } from "@remix-run/node" export async function action({ request }: ActionFunctionArgs) { const { to, subject, html } = await request.json() const res = await fetch("https://api.wesender.nl/emails", { method: "POST", headers: { "Authorization": `Bearer ${process.env.WESENDER_API_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ from: "noreply@joudomein.nl", to: [to], subject, html }), }) return json(await res.json(), { status: res.status }) } ``` ## Aanroepen vanuit de client ```typescript await fetch("/api/send-email", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ to: "klant@voorbeeld.nl", subject: "Welkom!", html: "Hoi!
" }), }) ``` --- # v0 Koppel Wesender aan een v0-gegenereerde Next.js-applicatie via een Server Action. ## Aanpak v0 genereert React-componenten. Voeg een Next.js Server Action toe om e-mails te versturen zonder de API-key in de browser. ## Server Action ```typescript // app/actions/send-email.ts "use server" export async function sendEmail(to: string, subject: string, html: string) { const res = await fetch("https://api.wesender.nl/emails", { method: "POST", headers: { "Authorization": `Bearer ${process.env.WESENDER_API_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ from: "noreply@joudomein.nl", to: [to], subject, html }), }) if (!res.ok) throw new Error(`Wesender fout: ${res.status}`) return res.json() } ``` ## Gebruik in een component ```tsx "use client" import { sendEmail } from "@/app/actions/send-email" export function ContactForm() { async function handleSubmit(formData: FormData) { await sendEmail( formData.get("email") as string, "Bedankt voor je bericht", "We nemen spoedig contact op.
" ) } return } ``` ## Omgevingsvariabele Voeg `WESENDER_API_KEY=ws_live_...` toe aan `.env.local`. Vercel leest dit automatisch bij de deployment.