Greenhouse gives you two default ways to put jobs on your site: link out to the hosted board, or drop in the iframe embed. Both work. But the iframe looks like Greenhouse, not like your site. Webflow CSS can't reach inside it, and it's a classic source of layout bugs like the footer overlapping a job that's open in the iframe.

There's a third way that most people don't know about. Greenhouse has a public Job Board API. It needs no key, and browsers can call it from any domain (it sends Access-Control-Allow-Origin: *). So a Webflow page can fetch your open roles and render them with elements you design in the Designer: your classes, your fonts, your hover states.

This guide walks through that in about 30 minutes.

What you'll build: a careers list with search, a department filter and a location filter, a role count, and an empty state. Every row is a Webflow Link Block that opens the job on Greenhouse, where candidates apply.

What you need:

  • A Greenhouse job board that's live (you can see it at job-boards.greenhouse.io/your-company)
  • A Webflow site on a paid Site plan or a paid Workspace, because Code Embeds and page custom code need one
  • No Zapier, no Make, no CMS items

1. Find your board token

Open your public Greenhouse board. The token is the last part of the URL:

text
https://job-boards.greenhouse.io/gitlab      → token: gitlab
https://boards.greenhouse.io/acme            → token: acme   (older URL format, same token)

Check it in your browser:

text
https://boards-api.greenhouse.io/v1/boards/YOUR_TOKEN/jobs

You should see JSON with a jobs array and meta.total. Two things can go wrong:

  • 404 {"status":404,"error":"Job not found"} means the token is wrong.
  • {"jobs":[],"meta":{"total":0}} means the token exists but nothing is published on the board. Publish your job posts to the external board in Greenhouse first.

2. Pick the right endpoint (this matters for speed)

Greenhouse has three useful read endpoints. They're all GET, all public, and all need no key:

EndpointWhat you getSize on a 248-job board*
/v1/boards/{token}/jobsTitle, location, URL, dates. No department.174,733 bytes
/v1/boards/{token}/jobs?content=trueEverything, including full HTML descriptions, departments and offices~3.9 MB
/v1/boards/{token}/departmentsEvery department with its jobs array nested inside188,640 bytes

*Measured on GitLab's public board on 19 Nov 2026.

For a careers list you want department filters, but you don't want 3.9 MB of job descriptions. Use /departments: you get each job's department for almost the same weight as the slim list.

A job inside /departments looks like this (trimmed):

json
{
  "id": 8928325002,
  "title": "Manager, SOX PMO - Business Process ",
  "absolute_url": "https://job-boards.greenhouse.io/gitlab/jobs/8928325002",
  "location": { "name": "Remote, Canada; Remote, India; Remote, United States" },
  "first_published": "2026-11-10T13:28:54-05:00",
  "updated_at": "2026-11-12T13:19:47-05:00",
  "requisition_id": "7359",
  "company_name": "GitLab"
}

Good to know:

  • Titles can have trailing spaces (see above). Trim them.
  • location.name is free text. One job can say "Remote, Canada; Remote, India; Remote, United States", so the location filter shows the strings exactly as your recruiters typed them.
  • Departments can be nested (parent_id). Jobs are listed under the department they're assigned to, and each job appears once. The script de-duplicates by id anyway.
  • There's also a "No Department" bucket for unassigned jobs.
  • absolute_url is the job's public page. If you've set a custom job board URL in Greenhouse, it may point to your own domain instead of greenhouse.io. Both are fine to link to.

3. Build the layout in the Designer

Build it like any other section. The script only looks for custom attributes (Element settings → Custom attributes), so class names and nesting are up to you.

ElementCustom attributeNotes
Text Field (or any input)data-jobs = searchOptional
Selectdata-jobs = departmentFirst option: label "All departments", value empty
Selectdata-jobs = locationFirst option: "All locations", value empty
Text spandata-jobs = countOptional: "24 open roles"
Div (the list wrapper)data-jobs = listRequired
↳ Link Block (one job row)data-jobs = templateRequired. Design it with dummy text
↳↳ Headingdata-job = title
↳↳ Textdata-job = department
↳↳ Textdata-job = location
Div (empty state)data-jobs = empty"No roles match. Try another filter."
Div (error state)data-jobs = error"Couldn't load jobs, see all roles on Greenhouse →"

Tips:

  • Design one row properly: hover state, divider, an arrow icon. Every job gets an exact copy of it.
  • The Select elements are native Webflow form selects. Put them in a Form Block if you want Webflow's form styling, but the script doesn't submit anything.
  • Keep the row a Link Block. The script sets its href to the Greenhouse job URL.

4. Hide the template and the states before the page paints

Page settings → Custom code → Inside <head> tag:

html
<style>
  [data-jobs="template"] { display: none !important; }
  [data-jobs="empty"], [data-jobs="error"] { display: none; }
</style>

Putting this in the head (not in an embed at the bottom) stops the "flash of the dummy row" before the jobs load. The rendered rows get a different attribute value (row), so the first rule doesn't hide them. The empty and error states have no !important, so the script can show them with an inline display: block. If your empty state is a flex container, change 'block' to 'flex' in the script.

5. Add the script

Page settings → Custom code → Before </body> tag. Paste this and change YOUR_BOARD_TOKEN:

html
<script>
(function () {
  const BOARD = 'YOUR_BOARD_TOKEN'; // e.g. "gitlab" from job-boards.greenhouse.io/gitlab
  const API = 'https://boards-api.greenhouse.io/v1/boards/' + encodeURIComponent(BOARD) + '/departments';

  const list = document.querySelector('[data-jobs="list"]');
  const template = document.querySelector('[data-jobs="template"]');
  const empty = document.querySelector('[data-jobs="empty"]');
  const errorBox = document.querySelector('[data-jobs="error"]');
  const count = document.querySelector('[data-jobs="count"]');
  const search = document.querySelector('[data-jobs="search"]');
  const deptSelect = document.querySelector('[data-jobs="department"]');
  const locSelect = document.querySelector('[data-jobs="location"]');
  if (!list || !template) return;

  let jobs = [];

  function safeUrl(u) {
    try { const url = new URL(u); return url.protocol === 'https:' ? url.href : null; }
    catch (e) { return null; }
  }

  function fillSelect(select, values) {
    if (!select) return;
    values.forEach(function (v) {
      const opt = document.createElement('option');
      opt.value = v; opt.textContent = v;
      select.appendChild(opt);
    });
  }

  function render() {
    const q = (search && search.value || '').trim().toLowerCase();
    const dept = deptSelect ? deptSelect.value : '';
    const loc = locSelect ? locSelect.value : '';
    const shown = jobs.filter(function (j) {
      return (!q || j.title.toLowerCase().includes(q)) &&
             (!dept || j.department === dept) &&
             (!loc || j.location === loc);
    });

    list.querySelectorAll('[data-jobs="row"]').forEach(function (el) { el.remove(); });
    shown.forEach(function (j) {
      const row = template.cloneNode(true);
      row.setAttribute('data-jobs', 'row');
      const set = function (name, value) {
        const el = row.querySelector('[data-job="' + name + '"]');
        if (el) el.textContent = value;
      };
      set('title', j.title);
      set('department', j.department);
      set('location', j.location);
      if (row.tagName === 'A' && j.url) row.href = j.url;
      list.appendChild(row);
    });

    if (count) count.textContent = String(shown.length);
    if (empty) empty.style.display = shown.length ? 'none' : 'block';
  }

  fetch(API, { headers: { Accept: 'application/json' } })
    .then(function (res) {
      if (!res.ok) throw new Error('Greenhouse returned ' + res.status);
      return res.json();
    })
    .then(function (data) {
      const seen = new Set();
      (data.departments || []).forEach(function (d) {
        (d.jobs || []).forEach(function (j) {
          if (seen.has(j.id)) return;
          seen.add(j.id);
          jobs.push({
            id: j.id,
            title: (j.title || '').trim(),
            department: d.name,
            location: (j.location && j.location.name) || '',
            url: safeUrl(j.absolute_url),
            published: j.first_published || j.updated_at || ''
          });
        });
      });
      jobs.sort(function (a, b) { return (Date.parse(b.published) || 0) - (Date.parse(a.published) || 0); });

      fillSelect(deptSelect, Array.from(new Set(jobs.map(function (j) { return j.department; }))).sort());
      fillSelect(locSelect, Array.from(new Set(jobs.map(function (j) { return j.location; }).filter(Boolean))).sort());

      [search, deptSelect, locSelect].forEach(function (el) {
        if (el) el.addEventListener(el === search ? 'input' : 'change', render);
      });
      render();
    })
    .catch(function (err) {
      console.error('[jobs]', err);
      if (errorBox) errorBox.style.display = 'block';
    });
})();
</script>

What it does:

  1. Fetches /departments once, with no key and no cookies.
  2. Flattens departments into one job list, de-duplicates by id, trims titles, and sorts newest first by first_published.
  3. Fills the department and location selects with the real values from your board.
  4. Clones your template row for each job, writes the text with textContent (so job titles can't inject HTML), and sets the link.
  5. Re-renders on every keystroke or filter change, and shows the empty state when nothing matches.
  6. If Greenhouse is down or the token is wrong, it shows your error state, which should link to the hosted board so candidates are never stuck.

6. Publish and test

Custom code doesn't run in the Designer canvas, so publish to your webflow.io staging domain and open the careers page there.

Checklist:

  • The role count matches meta.total from step 1
  • Each department appears once in the filter
  • Clicking a row opens the right job on Greenhouse
  • Searching nonsense shows the empty state
  • Changing the token to xyz-wrong shows the error state (change it back after!)

7. Common variations

Show only one department (e.g. a "Design jobs" page). In the script, add this line right after jobs.sort(...):

js
jobs = jobs.filter(function (j) { return j.department === 'Product Design'; });

Then delete the department select from that page.

Open jobs in a new tab. Add target="_blank" to the Link Block in the Designer. The clones copy it.

Group by department with headings. Sort by department, then title, and insert a heading element whenever the department changes. Or build one list per department.

8. What about SEO?

Be clear about the trade-off:

  • The list is rendered by JavaScript. Google renders JS and will usually see it, but your domain doesn't get one indexable page per job.
  • Each job's page stays on Greenhouse, which handles the job structured data. Greenhouse's help center covers how its hosted job posts show up in Google for Jobs.
  • If you need every job as its own page on your domain with your own JobPosting schema, you need a CMS sync (Make, n8n, or a small server that writes to the Webflow CMS API) and the CMS item limits that come with it. That's a separate guide.

For most company careers pages, "on-brand list + apply on Greenhouse" is the right balance: no sync to babysit, and jobs disappear the moment a recruiter closes them.

9. Troubleshooting

SymptomCauseFix
Nothing renders in the DesignerCustom code doesn't run in the canvasTest on the published site
Error state showsWrong token (404) or a typo in YOUR_BOARD_TOKENCheck step 1
0 roles but no errorBoard token exists but nothing is published externallyPublish jobs to the external board in Greenhouse
Dummy row flashes on loadHiding CSS is in the footer, not the headMove step 4's CSS to the head
Department filter shows sub-departmentsJobs are assigned to nested (child) departments in GreenhouseMap child names to a parent in the script, or tidy departments in Greenhouse
Location filter has odd combined valueslocation.name is free text in GreenhouseClean up locations in Greenhouse, or split on ; in the script

Want this without maintaining code?

I built RoleWall (https://rolewall.com) to do exactly this as one script tag. It works with Greenhouse, Ashby, Lever and Rippling, and adds load-more, sorting, remote/workplace filters, caching, and layouts you style in the Designer. The live demos on the site run against real public boards. It's free during early access.

The script in this guide is yours to copy and adapt. No attribution needed.

Related Greenhouse guides