Documentation

<?php
// Cart page: "Put my cart on my delelisten list"
$secret = getenv('DELELISTEN_SECRET');            // sk_live_…  (never in a web page or app)

$body = [
    'items' => [
        ['name' => 'Organic milk 1 l', 'quantity' => '2', 'url' => 'https://myshop.com/p/123'],
        ['name' => 'Rye bread', 'url' => 'https://myshop.com/p/456'],
    ],
    'return_url' => 'https://myshop.com/cart',    // where the customer comes back to
    'reference'  => 'cart-981',                     // your own id, optional
];

$ch = curl_init('https://delelisten.com/app/public/shop-api.php?r=add-requests');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode($body),
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json', 'X-Api-Key: ' . $secret],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 10,
]);
$answer = json_decode((string) curl_exec($ch), true);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status === 201) {
    header('Location: ' . $answer['url']);        // the customer picks a list, then returns
    exit;
}
error_log('delelisten: ' . ($answer['error']['message'] ?? 'no answer'));

// Back on https://myshop.com/cart?delelisten=added&count=2
if (($_GET['delelisten'] ?? '') === 'added') {
    echo (int) $_GET['count'] . ' products are now on your delelisten list.';
}

import json
import os
import urllib.error
import urllib.request

API = "https://delelisten.com/app/public/shop-api.php"
SECRET = os.environ["DELELISTEN_SECRET"]  # sk_live_…  (never in a web page or app)


def call(method, route, body=None):
    req = urllib.request.Request(
        f"{API}?r={route}",
        data=json.dumps(body).encode() if body is not None else None,
        method=method,
        headers={"Content-Type": "application/json", "X-Api-Key": SECRET},
    )
    try:
        with urllib.request.urlopen(req, timeout=10) as res:
            return json.load(res)
    except urllib.error.HTTPError as err:
        raise RuntimeError(json.load(err)["error"]["message"]) from err


request = call("POST", "add-requests", {
    "items": [
        {"name": "Organic milk 1 l", "quantity": "2", "url": "https://myshop.com/p/123"},
        {"name": "Rye bread", "url": "https://myshop.com/p/456"},
    ],
    "return_url": "https://myshop.com/cart",
    "reference": "cart-981",
})
print(request["url"])  # send the customer here (redirect, new window or in-app browser)

# Later: did the customer add it?
print(call("GET", "add-requests&id=" + request["id"])["status"])  # pending | added | cancelled | expired

// Node.js 18+ (built-in fetch)
const API = "https://delelisten.com/app/public/shop-api.php";
const SECRET = process.env.DELELISTEN_SECRET; // sk_live_…  (never in a web page or app)

async function createAddRequest(items, returnUrl, reference) {
  const res = await fetch(`${API}?r=add-requests`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-Api-Key": SECRET },
    body: JSON.stringify({ items, return_url: returnUrl, reference }),
  });
  const data = await res.json();
  if (!res.ok) throw new Error(data.error.message);
  return data; // { id, url, status, expires_at, ... }
}

// Express: a "Put my cart on delelisten" button posts here
app.post("/cart/delelisten", async (req, res) => {
  const items = req.session.cart.map((p) => ({ name: p.title, quantity: String(p.qty), url: p.url }));
  const request = await createAddRequest(items, "https://myshop.com/cart", req.session.cartId);
  res.redirect(303, request.url);
});

// Java 11+ (java.net.http)
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Delelisten {
    static final String API = "https://delelisten.com/app/public/shop-api.php";
    static final String SECRET = System.getenv("DELELISTEN_SECRET"); // sk_live_…
    static final HttpClient HTTP = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();

    /** Returns the JSON answer. Its "url" is where the customer picks a list. */
    public static String createAddRequest(String json) throws Exception {
        HttpRequest req = HttpRequest.newBuilder(URI.create(API + "?r=add-requests"))
                .header("Content-Type", "application/json")
                .header("X-Api-Key", SECRET)
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();
        HttpResponse<String> res = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
        if (res.statusCode() != 201) {
            throw new IllegalStateException("delelisten: " + res.body());
        }
        return res.body(); // read "url" with your JSON library (Jackson, Gson, ...)
    }

    public static void main(String[] args) throws Exception {
        String json = """
            {"items": [{"name": "Organic milk 1 l", "quantity": "2", "url": "https://myshop.com/p/123"}],
             "return_url": "https://myshop.com/cart", "reference": "cart-981"}""";
        System.out.println(createAddRequest(json));
    }
}

package delelisten

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

const api = "https://delelisten.com/app/public/shop-api.php"

type Item struct {
	Name     string `json:"name"`
	Quantity string `json:"quantity,omitempty"`
	URL      string `json:"url,omitempty"`
	Note     string `json:"note,omitempty"`
}

type AddRequest struct {
	ID         string `json:"id"`
	URL        string `json:"url"`
	Status     string `json:"status"`
	AddedCount int    `json:"added_count"`
}

var client = &http.Client{Timeout: 10 * time.Second}

func CreateAddRequest(items []Item, returnURL, reference string) (*AddRequest, error) {
	body, _ := json.Marshal(map[string]any{"items": items, "return_url": returnURL, "reference": reference})
	req, _ := http.NewRequest(http.MethodPost, api+"?r=add-requests", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Api-Key", os.Getenv("DELELISTEN_SECRET")) // sk_live_…
	res, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusCreated {
		var e struct {
			Error struct{ Message string } `json:"error"`
		}
		json.NewDecoder(res.Body).Decode(&e)
		return nil, fmt.Errorf("delelisten: %s", e.Error.Message)
	}
	var r AddRequest
	err = json.NewDecoder(res.Body).Decode(&r)
	return &r, err
}

// In your handler:
//   r, err := delelisten.CreateAddRequest(items, "https://myshop.com/cart", cartID)
//   http.Redirect(w, req, r.URL, http.StatusSeeOther)

// .NET 6+
using System.Net.Http.Json;
using System.Text.Json;

var http = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
http.DefaultRequestHeaders.Add("X-Api-Key", Environment.GetEnvironmentVariable("DELELISTEN_SECRET")); // sk_live_…

var res = await http.PostAsJsonAsync("https://delelisten.com/app/public/shop-api.php?r=add-requests", new
{
    items = new[] { new { name = "Organic milk 1 l", quantity = "2", url = "https://myshop.com/p/123" } },
    return_url = "https://myshop.com/cart",
    reference = "cart-981",
});
var data = await res.Content.ReadFromJsonAsync<JsonElement>();
if (!res.IsSuccessStatusCode)
    throw new Exception(data.GetProperty("error").GetProperty("message").GetString());

var addUrl = data.GetProperty("url").GetString(); // send the customer here

require "net/http"
require "json"

uri = URI("https://delelisten.com/app/public/shop-api.php?r=add-requests")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json",
                               "X-Api-Key" => ENV.fetch("DELELISTEN_SECRET")) # sk_live_…
req.body = {
  items: [{ name: "Organic milk 1 l", quantity: "2", url: "https://myshop.com/p/123" }],
  return_url: "https://myshop.com/cart",
  reference: "cart-981"
}.to_json

res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }
data = JSON.parse(res.body)
raise data["error"]["message"] unless res.code == "201"

redirect_to data["url"], allow_other_host: true # Rails: send the customer to delelisten

curl -X POST "https://delelisten.com/app/public/shop-api.php?r=add-requests" \
  -H "X-Api-Key: $DELELISTEN_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"items":[{"name":"Organic milk 1 l","quantity":"2","url":"https://myshop.com/p/123"}],
       "return_url":"https://myshop.com/cart","reference":"cart-981"}'

curl "https://delelisten.com/app/public/shop-api.php?r=add-requests&id=ar_THE_ID" -H "X-Api-Key: $DELELISTEN_SECRET"

import AuthenticationServices
import UIKit

/// Opens delelisten in a secure browser sheet. The customer stays signed in to delelisten (shared with Safari).
final class DelelistenButton: NSObject, ASWebAuthenticationPresentationContextProviding {
    static let publicKey = "pk_YOUR_PUBLIC_KEY"
    static let scheme = "myshop"                 // register "myshop://delelisten" under Return addresses
    private var session: ASWebAuthenticationSession?
    private weak var window: UIWindow?

    func add(name: String, quantity: String = "", productURL: String = "", from window: UIWindow?,
             done: @escaping (_ added: Int) -> Void) {
        var c = URLComponents(string: "https://delelisten.com/app/public/add.php")!
        c.queryItems = [
            URLQueryItem(name: "k", value: Self.publicKey),
            URLQueryItem(name: "n", value: name),
            URLQueryItem(name: "q", value: quantity),
            URLQueryItem(name: "u", value: productURL),
            URLQueryItem(name: "return", value: "\(Self.scheme)://delelisten"),
        ]
        c.percentEncodedQuery = c.percentEncodedQuery?.replacingOccurrences(of: "+", with: "%2B")
        self.window = window
        session = ASWebAuthenticationSession(url: c.url!, callbackURLScheme: Self.scheme) { url, _ in
            // url = myshop://delelisten?delelisten=added&count=1  (nil when the customer closed the sheet)
            let items = url.flatMap { URLComponents(url: $0, resolvingAgainstBaseURL: false)?.queryItems } ?? []
            let added = items.first { $0.name == "delelisten" }?.value == "added"
            done(added ? Int(items.first { $0.name == "count" }?.value ?? "0") ?? 0 : 0)
        }
        session?.presentationContextProvider = self
        session?.prefersEphemeralWebBrowserSession = false
        session?.start()
    }

    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
        window ?? ASPresentationAnchor()
    }
}

// build.gradle: implementation("androidx.browser:browser:1.8.0")
import android.content.Context
import android.net.Uri
import androidx.browser.customtabs.CustomTabsIntent

/** Opens delelisten in a Custom Tab. The customer stays signed in to delelisten (shared with Chrome). */
fun addToDelelisten(context: Context, name: String, quantity: String = "", productUrl: String = "") {
    val uri = Uri.parse("https://delelisten.com/app/public/add.php").buildUpon()
        .appendQueryParameter("k", "pk_YOUR_PUBLIC_KEY")
        .appendQueryParameter("n", name)
        .appendQueryParameter("q", quantity)
        .appendQueryParameter("u", productUrl)
        .appendQueryParameter("return", "myshop://delelisten") // registered under Return addresses
        .build()
    CustomTabsIntent.Builder().build().launchUrl(context, uri)
}

/* AndroidManifest.xml: catch the way back ("Back to My Shop" in delelisten)
<activity android:name=".DelelistenReturnActivity" android:exported="true">
  <intent-filter>
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="myshop" android:host="delelisten" />
  </intent-filter>
</activity>

In DelelistenReturnActivity:
  val status = intent.data?.getQueryParameter("delelisten")   // "added" or "cancelled"
  val count = intent.data?.getQueryParameter("count")?.toIntOrNull() ?: 0
*/

// The same add link works from any app framework. Open it in the system's in-app browser
// (not in a WebView, where the customer is not signed in to delelisten), and listen for
// your return address, e.g. myshop://delelisten?delelisten=added&count=1

// Flutter (package flutter_web_auth_2):
final result = await FlutterWebAuth2.authenticate(
  url: Uri.parse('https://delelisten.com/app/public/add.php').replace(queryParameters: {
    'k': 'pk_YOUR_PUBLIC_KEY', 'n': 'Organic milk 1 l', 'q': '2',
    'u': 'https://myshop.com/p/123', 'return': 'myshop://delelisten',
  }).toString(),
  callbackUrlScheme: 'myshop',
);

// React Native (Expo, expo-web-browser):
const params = new URLSearchParams({ k: 'pk_YOUR_PUBLIC_KEY', n: 'Organic milk 1 l', q: '2',
  u: 'https://myshop.com/p/123', return: 'myshop://delelisten' });
const result = await WebBrowser.openAuthSessionAsync('https://delelisten.com/app/public/add.php?' + params, 'myshop://delelisten');
// result.type === 'success' -> new URL(result.url).searchParams.get('delelisten')