DEV Community: Digitální produkty pro život

Build a niche job board from company career sites with the Greenhouse, Lever and Ashby APIs

Digitální produkty pro život — Tue, 13 Oct 2026 06:24:49 +0000

Most job boards fill up with reposts, agency ads and stale listings. The cleanest source is the companies' own career sites. Many startups and scale-ups publish every opening through an applicant tracking system (ATS) such as Greenhouse, Lever or Ashby, and these ATS offer public job board APIs that need no API key.

The catch is that every ATS has its own format. This post shows how to read three of them and merge the results into one schema, in plain Node.js (18+, built-in fetch, no dependencies).

The three public endpoints

ATS	Endpoint (replace `{slug}` with the company's board name)
Greenhouse	`https://boards-api.greenhouse.io/v1/boards/{slug}/jobs?content=true`
Lever	`https://api.lever.co/v0/postings/{slug}?mode=json`
Ashby	`https://api.ashbyhq.com/posting-api/job-board/{slug}?includeCompensation=true`

The slug is the part of the company's careers URL after the ATS domain, for example boards.greenhouse.io/airbnb → airbnb, jobs.lever.co/palantir → palantir, jobs.ashbyhq.com/ramp → ramp.

One schema for all three

// jobs.mjs  (run with: node jobs.mjs)
const SOURCES = {
  greenhouse: async (slug) => {
    const r = await fetch(`https://boards-api.greenhouse.io/v1/boards/${slug}/jobs?content=true`);
    const { jobs } = await r.json();
    return jobs.map((j) => ({
      ats: 'greenhouse', company: slug, title: j.title, location: j.location?.name ?? null,
      postedAt: j.first_published ?? j.updated_at, url: j.absolute_url,
    }));
  },
  lever: async (slug) => {
    const r = await fetch(`https://api.lever.co/v0/postings/${slug}?mode=json`);
    return (await r.json()).map((j) => ({
      ats: 'lever', company: slug, title: j.text, location: j.categories?.location ?? null,
      postedAt: new Date(j.createdAt).toISOString(), url: j.hostedUrl,
    }));
  },
  ashby: async (slug) => {
    const r = await fetch(`https://api.ashbyhq.com/posting-api/job-board/${slug}?includeCompensation=true`);
    const { jobs } = await r.json();
    return jobs.filter((j) => j.isListed !== false).map((j) => ({
      ats: 'ashby', company: slug, title: j.title, location: j.location ?? null,
      postedAt: j.publishedAt, url: j.jobUrl,
    }));
  },
};

const companies = [['greenhouse', 'airbnb'], ['lever', 'palantir'], ['ashby', 'ramp']];
const all = (await Promise.all(companies.map(([ats, slug]) => SOURCES[ats](slug)))).flat();
const wanted = all.filter((j) => /engineer/i.test(j.title) && /remote|new york/i.test(j.location ?? ''));
wanted.sort((a, b) => String(b.postedAt).localeCompare(String(a.postedAt)));
console.log(`${all.length} open jobs, ${wanted.length} match`);
for (const j of wanted.slice(0, 5)) console.log(j.postedAt?.slice(0, 10), j.ats, j.company, '|', j.title, '|', j.location);

When I ran it on October 13, 2026 it printed 638 open jobs, 118 match, followed by the five newest matching engineering roles. Your numbers will differ, because the boards change every day.

Things worth knowing about the fields:

Salary: Ashby returns a compensation object (with includeCompensation=true) when the company chooses to show pay. Many postings have no salary at all, so treat it as optional.
Dates: Greenhouse gives first_published and updated_at, Lever a millisecond createdAt, Ashby publishedAt. Normalize to ISO strings before sorting.
Descriptions: Greenhouse returns HTML (content=true), Lever gives descriptionPlain, Ashby descriptionPlain/descriptionHtml. Strip HTML before storing.

A daily "new jobs only" feed

For a niche board (remote, AI, climate, one city), run the fetch once a day and keep only postings you haven't seen before. A file of seen URLs is enough to start with:

import { existsSync, readFileSync, writeFileSync } from 'node:fs';
const SEEN_FILE = 'seen.json';
const seen = new Set(existsSync(SEEN_FILE) ? JSON.parse(readFileSync(SEEN_FILE, 'utf8')) : []);
const r = await fetch('https://boards-api.greenhouse.io/v1/boards/airbnb/jobs');
const { jobs } = await r.json();
const fresh = jobs.filter((j) => !seen.has(j.absolute_url));
for (const j of fresh) seen.add(j.absolute_url);
writeFileSync(SEEN_FILE, JSON.stringify([...seen]));
console.log(`${fresh.length} new of ${jobs.length}`);

The first run reports every posting as new (163 new of 163 in my test), the second one 0 new of 163. Schedule it with cron or a GitHub Actions workflow and append the fresh jobs to your database or CMS.

Finding which companies use which ATS

There is no official list. Practical ways to build one:

Open a company's careers page and click a job: the link shows the ATS (boards.greenhouse.io, jobs.lever.co, jobs.ashbyhq.com).
Keep a curated list of the companies your audience cares about (for example a VC portfolio or a city's tech scene) rather than trying to cover everything.
Other ATS have public endpoints too (SmartRecruiters, Recruitee, Personio, Workable); check each one's documentation before adding it.

Be a good citizen

Cache results and fetch each board at most a few times a day; a 404 means the board was removed or renamed.
Read each ATS's API terms and the companies' own terms before republishing.
Link every listing back to the original posting, which is where candidates apply. The descriptions are the employers' content.
Descriptions occasionally contain a recruiter's name or e-mail. Use such details only for the job application purpose and do not reuse them for marketing.

This post was written with AI assistance. The code was run and checked on October 13, 2026 (Node.js 24).

The remove.bg API moves to Leonardo.Ai on Dec 1, 2026: a provider-neutral migration checklist

Digitální produkty pro život — Sun, 11 Oct 2026 01:26:18 +0000

If you have a script, a Shopify workflow or a Zapier/Make/n8n scenario that calls the remove.bg API, put a date in your calendar: remove.bg's API page says that starting December 1, 2026, background removal moves to Leonardo.Ai (also part of Canva). This post is a provider-neutral checklist for getting through that change without rewriting your code twice.

1. Find every call

Search your code, automations and no-code scenarios for:

api.remove.bg and /v1.0/removebg
the X-Api-Key header
client libraries: Python removebg, Node remove.bg, PHP mtownsend/remove-bg
Zapier, Make and n8n remove.bg modules

A typical call looks like this:

import requests

r = requests.post(
    "https://api.remove.bg/v1.0/removebg",
    data={"image_url": "https://example.com/shoe.jpg", "size": "auto", "bg_color": "ffffff"},
    headers={"X-Api-Key": "<REMOVE_BG_KEY>"},
)
open("shoe.png", "wb").write(r.content)

Note which parameters you actually use (size, bg_color, crop, format, channels, shadows…). That list decides which replacement fits.

2. Check your account

Read remove.bg's own announcement and FAQ for what happens to your plan, remaining credits and API keys, and plan the switch before the deadline rather than on the day.

3. Put the provider behind one function

Whatever you pick, wrap the call so the provider becomes configuration instead of code. Then the next change (or an A/B test of two providers) is one environment variable:

// bg.mjs: one function for background removal; the provider is configuration, not code.
const PROVIDERS = {
  removebg: {
    url: 'https://api.remove.bg/v1.0/removebg',
    headers: () => ({ 'X-Api-Key': process.env.REMOVE_BG_KEY }),
  },
  // Add the provider you migrate to here (its URL, auth header and field names).
};

export async function removeBackground(imageUrl, provider = process.env.BG_PROVIDER ?? 'removebg') {
  const p = PROVIDERS[provider];
  if (!p) throw new Error(`Unknown provider: ${provider}`);
  const form = new FormData();
  form.set('image_url', imageUrl);
  form.set('size', 'auto');
  const r = await fetch(p.url, { method: 'POST', headers: p.headers(), body: form });
  if (!r.ok) throw new Error(`${provider}: HTTP ${r.status} ${await r.text()}`);
  return Buffer.from(await r.arrayBuffer());
}

I tested it on October 13, 2026 (Node.js 24) against a local mock provider and against the real remove.bg endpoint without a key, which correctly returns HTTP 403 … API Key invalid. If the new provider uses different field names or returns JSON instead of an image, translate that inside the provider entry, not in your callers.

4. Choose a replacement

Leonardo.Ai: the official path announced by remove.bg, if you want to stay with the same company.
Self-hosting: open-source segmentation models such as ISNet (DIS, Apache-2.0) or BiRefNet, and the rembg project (MIT), run on your own server. No per-image fee, but you run and scale the server; a GPU helps for large volumes.
Another hosted API: several services offer pay-per-image background removal. Compare price per image, maximum resolution, rate limits and data retention.

5. Test on your own images

Edge quality on hair, fur, jewellery, glass and fine product details varies a lot between models. Run the same 20–50 of your real photos through each candidate, compare the results side by side, and only then switch the BG_PROVIDER setting in production.

This post was written with AI assistance. The code was run and checked on October 13, 2026. I am not affiliated with remove.bg, Canva or Leonardo.Ai.

Turn PDFs into page-aware text chunks for your RAG pipeline (Node.js + pdf.js)

Digitální produkty pro život — Fri, 09 Oct 2026 12:14:43 +0000

PDF parsing is the boring part of every RAG project. Line breaks in the middle of sentences, headers and footers mixed into the text, no page numbers to cite. This post shows a small, dependency-light way to turn a PDF into page-aware text chunks in Node.js, plus the pitfalls I hit while testing it.

Extract text per page

unpdf (MIT) wraps Mozilla's pdf.js and runs in Node.js (22+ for the default build), Deno, Bun and serverless workers:

npm install unpdf

// pdf.mjs  (run with: node pdf.mjs)
import { extractText, getDocumentProxy } from 'unpdf';

const url = 'https://arxiv.org/pdf/1706.03762';
const buffer = new Uint8Array(await (await fetch(url)).arrayBuffer());
const pdf = await getDocumentProxy(buffer);
const { totalPages, text: pages } = await extractText(pdf, { mergePages: false });

// Collapse whitespace: line breaks inside sentences become spaces.
const clean = (t) => t.replace(/\s+/g, ' ').trim();

mergePages: false returns one string per page, which you need if you want answers like "see page 12".

Chunk for embeddings

// ~1,000-character chunks split after sentence-ending punctuation, ~100 characters of overlap,
// and the page number kept for citations.
function chunk(text, page, size = 1000, overlap = 100) {
  const sentences = text.split(/(?<=[.!?])\s+/);
  const chunks = [];
  let current = '';
  for (const s of sentences) {
    if (current && current.length + s.length + 1 > size) {
      chunks.push({ page, text: current.trim() });
      current = current.slice(-overlap);
    }
    current += `${s} `;
  }
  if (current.trim()) chunks.push({ page, text: current.trim() });
  return chunks;
}

const chunks = pages.flatMap((t, i) => chunk(clean(t), i + 1));
console.log(`${totalPages} pages, ${chunks.length} chunks`);

On the "Attention Is All You Need" paper this printed 15 pages, 49 chunks (tested October 13, 2026). Each chunk is { page, text }, ready to embed and upsert into your vector database with the page as metadata.

Pitfalls I hit while testing

Don't split sentences with a "match everything up to a period" regex. My first version used text.match(/[^.!?]+[.!?]+(\s|$)/g) and silently dropped fragments: "28.4 BLEU" became "4 BLEU". Splitting after ., ! or ? followed by whitespace keeps every character.
Don't blindly join hyphenated line breaks. Removing - + line break also glued real hyphenated words ("English-to-German" became "Englishto-German"). Either leave hyphens alone or only join when a dictionary says the joined word exists.
Headers, footers and author blocks end up in the text. The first chunk of the paper starts with a copyright notice and the authors' e-mail addresses. Strip repeated lines that appear on every page, and drop personal details such as e-mails if your use case doesn't need them.
Headings are lost in plain text extraction. If you need Markdown headings, pdf.js exposes font sizes per text item (page.getTextContent()), so you can treat lines with a larger font as headings.
Tables and multi-column layouts come out as text in the PDF's internal order, which is usually but not always the reading order.

Scanned PDFs need OCR

A scanned PDF is just images, so extractText returns empty strings. Detect that case (for example, fewer than ~20 characters on a page) and send those pages to OCR, such as Tesseract, or OCRmyPDF to add a text layer first. OCR quality depends heavily on the scan: clean 300 DPI scans work well, while phone photos, handwriting and small print do not.

This post was written with AI assistance. The code was run and checked on October 13, 2026 (Node.js 24, unpdf 1.8.1).