Exporting bookmarks

Using a valid API token for the Queso browser extension can also be used for scripts, automations and even AI using the Queso Bookmarks API. In the example below we go over how to use the Queso API to bulk export bookmarks.

Node

const token = process.env.QUESO_TOKEN;
const base = process.env.QUESO_API ?? "https://quesobookmarks.com/api/v1";

if (!token) {
  throw new Error("Missing QUESO_TOKEN");
}

async function fetchAllBookmarks() {
  const bookmarks = [];

  for (let page = 1; page <= 50; page += 1) {
    const res = await fetch(`${base}/bookmarks/?limit=100&page=${page}`, {
      headers: { Authorization: `Bearer ${token}` },
    });

    if (!res.ok) {
      throw new Error(`HTTP ${res.status}`);
    }

    const payload = await res.json();
    bookmarks.push(...payload.data);

    if (!payload.data.length) break;
  }

  return bookmarks;
}

fetchAllBookmarks().then((data) => {
  console.log(`Exported ${data.length} bookmarks`);
});

Python

import os
import requests

token = os.getenv("QUESO_TOKEN")
if not token:
    raise RuntimeError("Missing QUESO_TOKEN")

base = os.getenv("QUESO_API", "https://quesobookmarks.com/api/v1").rstrip("/")

def fetch_all_bookmarks(limit=100, max_pages=50):
    bookmarks = []
    headers = {"Authorization": f"Bearer {token}"}

    for page in range(1, max_pages + 1):
        r = requests.get(
            f"{base}/bookmarks/",
            headers=headers,
            params={"limit": limit, "page": page},
            timeout=30,
        )
        r.raise_for_status()
        payload = r.json()
        batch = payload.get("data", [])
        bookmarks.extend(batch)

        if not batch:
            break

    return bookmarks

data = fetch_all_bookmarks()
print(f"Exported {len(data)} bookmarks")

Go

package main

import (
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "net/url"
  "os"
  "strconv"
  "strings"
  "time"
)

type Response struct {
  Data []any `json:"data"`
}

func main() {
  token := os.Getenv("QUESO_TOKEN")
  if token == "" {
    panic("Missing QUESO_TOKEN")
  }

  base := os.Getenv("QUESO_API")
  if base == "" {
    base = "https://quesobookmarks.com/api/v1"
  }
  base = strings.TrimRight(base, "/")

  bookmarks, err := fetchAllBookmarks(base, token, 100, 50)
  if err != nil {
    panic(err)
  }

  fmt.Printf("Exported %d bookmarks\n", len(bookmarks))
}

func fetchAllBookmarks(base, token string, limit, maxPages int) ([]any, error) {
  client := &http.Client{Timeout: 30 * time.Second}
  results := make([]any, 0, limit)

  for page := 1; page <= maxPages; page++ {
    u, _ := url.Parse(base + "/bookmarks/")
    q := u.Query()
    q.Set("limit", strconv.Itoa(limit))
    q.Set("page", strconv.Itoa(page))
    u.RawQuery = q.Encode()

    req, _ := http.NewRequest("GET", u.String(), nil)
    req.Header.Set("Authorization", "Bearer "+token)

    res, err := client.Do(req)
    if err != nil {
      return nil, err
    }

    body, _ := io.ReadAll(res.Body)
    res.Body.Close()

    if res.StatusCode < 200 || res.StatusCode >= 300 {
      return nil, fmt.Errorf("http %d: %s", res.StatusCode, body)
    }

    var payload Response
    if err := json.Unmarshal(body, &payload); err != nil {
      return nil, err
    }

    results = append(results, payload.Data...)
    if len(payload.Data) == 0 {
      break
    }
  }

  return results, nil
}

Curl

curl -s \
  -H "Authorization: Bearer $QUESO_TOKEN" \
  "$QUESO_API/bookmarks/?limit=100&page=1"