DEV Community: Gleanery Works

Finding European manufacturers with VAT IDs: a sourcing workflow with Europages data

Gleanery Works — Fri, 23 Oct 2026 07:49:28 +0000

When you need a manufacturer in Europe (a private-label cosmetics lab, a CNC machining subcontractor in Poland, an olive-oil producer in Spain), you usually start on Europages. It lists over 3 million companies, and they fill in their own profiles: products, employee count, founding year, sales area, and often their VAT number, payment terms and incoterms.

The problem is the interface. You click through 30 results per page, open each profile, and copy fields into a spreadsheet by hand.

A faster workflow

Search wide. Product keyword plus countries, e.g. cnc machining in Poland, Czechia, Slovakia and Hungary. Europages caps each search at 3,000 results, so split big searches by country.
Filter hard. Keep only manufacturers (not distributors), with 20–199 employees, an international sales area and a website. That usually cuts the list by 80%.
Enrich the shortlist. Pull the VAT ID, main industry, payment methods and terms, incoterms, certificates and product keywords from each profile.
Verify the VAT ID in the EU's VIES service. It's a quick check that the company is a real, registered business.
Compare and contact. Sort by size, founding year and trade terms, then contact the top 10 through their website.

What the data looks like

{
  "companyName": "SOGA Spaces Office Furniture",
  "country": "TR",
  "city": "Istanbul",
  "website": "https://www.sogaspaces.com",
  "phone": "+905336997642",
  "employeeCount": "20-49",
  "supplierTypes": ["production"],
  "distributionArea": "international",
  "industry": "Furniture and contract furnishing",
  "vatId": "TR7721315900",
  "paymentTerms": ["payment_on_account"],
  "incoterms": ["cost_insurance_and_freight", "free_on_board"],
  "keywords": ["Acoustic panels", "Office desks", "Meeting tables"]
}

A note on GDPR

Company data (name, website, switchboard phone, VAT ID) is business information that companies publish so buyers can find them. Named contact persons are personal data. Leave them out, and follow your country's ePrivacy rules before cold-emailing anyone.

Tooling

I built Europages Scraper for steps 1–3. It covers keyword plus country search with automatic splitting past the 3,000 limit, filters for supplier type, size, sales area and founding year, and VAT/trade-terms enrichment. It deliberately leaves out personal data. It costs $1 per 1,000 companies, all-in.

Ready-made searches you can copy:

Let an AI agent do the sourcing: add https://mcp.apify.com?tools=gleanery_actors/europages-scraper as an MCP server in Claude, Cursor or ChatGPT, and ask "Find 30 private-label cosmetics manufacturers in Italy and France with more than 20 employees, with VAT IDs, and rank them by size." (setup guide)

What are you sourcing? Tell me in the comments and I'll suggest a search.

Startup salaries and equity, as data: exporting Wellfound (AngelList) jobs

Gleanery Works — Thu, 22 Oct 2026 07:57:11 +0000

Wellfound (formerly AngelList Talent) is unusual among job boards: most listings show both a salary range and an equity range, plus the company's funding stage, size and investor badges. That makes it the best public dataset on startup compensation, if you can get it out of the website.

Where the data lives

Wellfound is a Next.js app. Each search page (/role/software-engineer, /location/berlin, /remote) ships its data in a <script id="__NEXT_DATA__"> tag as an Apollo cache. The useful records are:

JobListingSearchResult: title, compensation (a display string like $120k – $160k • 0.1% – 0.5%), jobType, remote, locationNames, yearsExperienceMin, liveStartAt, and a reference to the startup.
StartupResult: name, companySize, highConcept (one-liner), and badges[] such as Actively hiring, Top investors, B2B and the funding stage.

The job detail page adds a schema.org JobPosting block in ld+json. It has the company website, industry, benefits, directApply, applicant location requirements and a structured baseSalary with its unit (year/month/hour).

The annoying parts

Compensation is a string. You need to parse $120k – $160k, €50K – €70K, ₹15L – ₹25L and 0.1% – 1.0% into min/max numbers and currencies. Watch out for k, m and Indian lakh (L) multipliers.
Pagination stops around page 46, so a broad query like "software engineer" doesn't return everything. Split by role and location.
Detail pages cost requests. You only need them for the website, industry and salary period, so fetch them in parallel with a small concurrency limit.
Daily feeds. If you run this every morning, you want only new jobs. Keep a hash of each job's key fields between runs.

What you can do with it

Comp benchmarking: median salary and equity for a senior engineer at a seed-stage vs. Series B company.
Job hunting at scale: filter all remote jobs by minimum salary, then sort by equity.
Lead lists: seed-stage startups that are actively hiring are startups that just raised money. Recruiters, agencies and dev shops sell to them.
Job boards and newsletters: a daily feed of new remote startup jobs.

The shortcut

I packaged all of the above as Wellfound Jobs Scraper on Apify. It returns salary and equity as numbers, plus company website, industry, stage, size, investor badges and remote policy. It has filters (minimum salary, equity only, company stage, years of experience) and a "new jobs only" mode for daily schedules. Pricing is pay per result, $0.90 per 1,000 jobs.

Some ready-made searches:

From an AI agent: add https://mcp.apify.com?tools=gleanery_actors/wellfound-jobs-scraper as an MCP server in Claude, Cursor or ChatGPT, and ask "Find 20 remote seed-stage startups hiring ML engineers that offer equity, with their websites." (setup guide)

If you do a compensation analysis with it, I'd love to see the charts.

The Arbeitsagentur Jobsuche API in 2026: search 1 million German jobs with Python (v6 endpoint)

Gleanery Works — Wed, 21 Oct 2026 07:20:46 +0000

The job board of Germany's Federal Employment Agency (Bundesagentur für Arbeit, arbeitsagentur.de/jobsuche) lists over 1 million open jobs: the largest job database in Germany, covering everything from nurses and electricians to software developers and apprenticeships. Its frontend talks to a JSON API that is open to everyone with a fixed public key.

Many tutorials and wrappers still use the old /pc/v4/jobs search endpoint, which now returns HTTP 403. Here's what works today (checked October 2026).

Search: `/pc/v6/jobs`

import requests

API = "https://rest.arbeitsagentur.de/jobboerse/jobsuche-service/pc"
HEADERS = {"X-API-Key": "jobboerse-jobsuche", "Accept": "application/json"}

r = requests.get(f"{API}/v6/jobs", headers=HEADERS, params={
    "was": "Softwareentwickler",   # what: job title or keyword
    "wo": "Berlin",                # where: city or postal code
    "umkreis": 25,                 # radius in km
    "size": 100, "page": 1,
})
data = r.json()
print(data["maxErgebnisse"], "matching jobs")
for job in data["ergebnisliste"]:
    print(job["stellenangebotsTitel"], "|", job.get("firma"), "|", job["stellenlokationen"][0]["adresse"].get("ort"))

Each result has the title, employer (firma), workplace address with coordinates, working-time flags, contract type (vertragsdauer), home office flag (homeofficemoeglich), publication date and the reference number (referenznummer).

Parameters that work

Parameter	Values	Meaning
`was`	text	job title or keyword
`wo`, `umkreis`	city/PLZ, km	location and radius
`angebotsart`	1 job, 2 self-employment, 4 apprenticeship, 34 internship	offer type
`arbeitszeit`	`vz`, `tz`, `snw`, `mj`, joined with `;`	full-time, part-time, shift/night/weekend, mini job
`befristung`	1 fixed-term, 2 permanent	contract
`veroeffentlichtseit`	0, 1, 7, 14, 28	published within N days (other values are ignored)
`zeitarbeit`	`false`	exclude temp agencies (Zeitarbeit)
`pav`	`false`	exclude private placement agencies
`arbeitgeber`	exact employer name	one employer
`page`, `size`	size up to 100	pagination

Two gotchas:

10,000 results max per query. page * size above 10,000 returns HTTP 400. Split big searches by location or date.
There's no home office search parameter in v6. Filter on homeofficemoeglich == True yourself.

The response also contains facetten (facet counts per occupation, city, employer, working time…), which is handy for labor-market statistics without downloading jobs.

Salaries

About a quarter of listings state pay:

for job in data["ergebnisliste"]:
    if "gehaltsspanneVon" in job:          # range
        print(job["gehaltsspanneVon"], "-", job["gehaltsspanneBis"], job["verguetungsangabe"])
    elif "festgehalt" in job:              # fixed amount
        print(job["festgehalt"], job["verguetungsangabe"])

verguetungsangabe is the unit: JAHRESGEHALT (yearly), STUNDENLOHN (hourly) or KEINE_ANGABEN (none).

Details: still `/pc/v4/jobdetails`, base64-encoded

The full description is on a separate endpoint. Unlike search, it's still v4, and it wants the reference number base64-encoded:

import base64

ref = data["ergebnisliste"][0]["referenznummer"]
enc = base64.b64encode(ref.encode()).decode()
detail = requests.get(f"{API}/v4/jobdetails/{enc}", headers=HEADERS).json()
print(detail["stellenangebotsBeschreibung"][:500])
print(detail.get("istArbeitnehmerUeberlassung"), detail.get("allianzpartnerName"))

The details add the description, the temp-agency and private-recruiter flags, and allianzpartnerName/allianzpartnerUrl. Careful: the "Allianzpartner" is whoever delivered the posting, which is often a partner job board (jobvector, yourfirm…) and not the employer, so don't treat its URL as the company website unless the names match.

The public job page is https://www.arbeitsagentur.de/jobsuche/jobdetail/{referenznummer}.

Skip the plumbing

If you'd rather not handle pagination, the 10k cap, detail requests, salary normalization and English field names yourself, I packaged all of this as an Apify actor: Arbeitsagentur Jobs Scraper. It returns flat JSON (title, companyName, city, salaryMin, salaryMax, salaryInterval, remote, isTempAgency…), adds filters like remoteOnly, minSalaryYearly and excludeTempAgencies, and has a monitoring mode for daily feeds. It costs $0.40 per 1,000 jobs.

For AI agents

It's also callable as an MCP tool, for example from Claude or Cursor:

https://mcp.apify.com?tools=gleanery_actors/arbeitsagentur-jobs-scraper

Ask "find part-time nursing jobs in Hamburg posted this week, direct employers only" and the agent fills in the input. More job and B2B data tools for agents: github.com/gleanery-works/job-and-supplier-data-mcp.

Get every open job from Greenhouse, Lever and Ashby in 40 lines of Python

Gleanery Works — Tue, 20 Oct 2026 12:45:53 +0000

If you want to build a job board, track which companies are hiring, or benchmark salaries, you don't need to scrape HTML. Most companies' careers pages are hosted by an applicant tracking system (ATS), and the three most common ones with startups (Greenhouse, Lever and Ashby) all have public, unauthenticated JSON endpoints. The careers page itself calls them.

1. Find out which ATS a company uses

Open the careers page and click any job. The URL tells you:

URL contains	ATS	Slug
`boards.greenhouse.io/stripe` or `job-boards.greenhouse.io/stripe`	Greenhouse	`stripe`
`jobs.lever.co/palantir`	Lever	`palantir`
`jobs.ashbyhq.com/openai`	Ashby	`openai`

If the careers page lives on the company's own domain, view the source and search for those hostnames: the job list is usually embedded from one of them.

2. Call the endpoint

import requests

HEADERS = {"User-Agent": "my-job-tracker/1.0 (you@example.com)"}

def greenhouse(slug):
    r = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs",
                     params={"content": "true"}, headers=HEADERS, timeout=30)
    for j in r.json()["jobs"]:
        yield {"title": j["title"], "location": j["location"]["name"],
               "department": (j.get("departments") or [{}])[0].get("name"),
               "url": j["absolute_url"], "posted": j.get("first_published")}

def lever(slug):
    skip = 0
    while True:
        page = requests.get(f"https://api.lever.co/v0/postings/{slug}",
                            params={"mode": "json", "skip": skip, "limit": 100},
                            headers=HEADERS, timeout=30).json()
        for j in page:
            yield {"title": j["text"], "location": j["categories"].get("location"),
                   "department": j["categories"].get("team"), "url": j["hostedUrl"],
                   "remote": j.get("workplaceType") == "remote",
                   "salary": j.get("salaryRange")}
        if len(page) < 100:
            break
        skip += 100

def ashby(slug):
    r = requests.get(f"https://api.ashbyhq.com/posting-api/job-board/{slug}",
                     params={"includeCompensation": "true"}, headers=HEADERS, timeout=30)
    for j in r.json()["jobs"]:
        comp = (j.get("compensation") or {}).get("compensationTierSummary")
        yield {"title": j["title"], "location": j.get("location"),
               "department": j.get("department"), "url": j["jobUrl"],
               "remote": j.get("isRemote"), "salary": comp}

for job in ashby("openai"):
    print(job)

That's it: no API key, no headless browser, and no HTML parsing.

3. Salary ranges

Pay-transparency laws in New York, California, Colorado, Washington and soon the EU mean many postings now carry a salary range, and the APIs expose it:

Ashby: compensation.summaryComponents[] has minValue, maxValue, currencyCode and interval per component (salary, equity, bonus).
Lever: salaryRange with min, max, currency, interval (e.g. per-year-salary).
Greenhouse: not in the list response. Fetch each job with ?pay_transparency=true and read pay_input_ranges[] (min_cents, max_cents, currency_type).

def greenhouse_pay(slug, job_id):
    d = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs/{job_id}",
                     params={"pay_transparency": "true"}, headers=HEADERS, timeout=30).json()
    return [(p["min_cents"] / 100, p["max_cents"] / 100, p["currency_type"])
            for p in d.get("pay_input_ranges", [])]

4. Gotchas I hit

Greenhouse EU boards live on boards-api.eu.greenhouse.io.
Lever EU accounts use api.eu.lever.co.
Slugs are not company names. "Hugging Face" might be huggingface or hugging-face, and on some ATSs a generic slug like remote or figure belongs to a different company. Check the company name the API returns before trusting a guessed slug.
Be polite. These endpoints serve real careers pages. Cache, keep concurrency low and send a User-Agent with contact info.

Beyond these three

Enterprise employers use Workday (a POST API with a 20-item page limit and a total that only appears on page 1), and European companies often use Personio (XML), Recruitee, SmartRecruiters or Workable. I documented the endpoints for 11 ATSs, with their pagination quirks and salary fields, here: github.com/gleanery-works/ats-job-apis.

If you'd rather not maintain eleven integrations, I also run them as a hosted tool, Career Site Jobs Scraper. You give it company names, and it finds each company's ATS and returns one normalized schema with salary min/max. It can also return only jobs that are new since the last run, which is handy for hiring-signal alerts. It's pay per result ($1 per 1,000 jobs), and Apify's free monthly credit covers small projects.

Giving an AI agent access to job data

If the consumer is an LLM agent rather than your own code, you can skip the integration entirely and expose the tool over MCP:

claude mcp add --transport http jobs "https://mcp.apify.com?tools=gleanery_actors/career-site-jobs-scraper"

Then ask: "Which of Datadog, Snowflake and Figma opened data-engineering roles this week, and what do they pay?" The agent calls the tool with {"companies": [...], "titleKeywords": ["data engineer"], "postedWithinDays": 7} and gets normalized JSON back. Setup for Cursor, Claude Desktop and VS Code is in gleanery-works/job-and-supplier-data-mcp.

What are you building with job data? I'm curious which ATSs people still miss.