Lever's hosted jobs page is reliable, but it leaves your Webflow careers page with a familiar choice: send visitors away immediately, or accept a vendor-owned presentation that does not use the components you designed.

The public Lever Postings API gives you a third option. It returns published jobs without an API key, so your page can render them into normal Webflow Link Blocks. The endpoint looks simple, but two details cause most broken implementations: Lever has separate US and EU hosts, and browser requests must not add custom headers.

This guide handles both.

What you'll build: a searchable Lever job list with department, location and workplace filters, a role count, empty and error states, and links to the hosted job pages where candidates apply.

What you need:

  • A public Lever board at jobs.lever.co/{site} or jobs.eu.lever.co/{site}
  • A Webflow plan that permits page custom code
  • One job row designed in the Designer
  • No Lever API key, Zapier, Make or CMS collection

1. Find the Lever site name and region

The site name is the first path segment after the host:

text
https://jobs.lever.co/leverdemo       → site: leverdemo, region: US
https://jobs.eu.lever.co/lever        → site: lever, region: EU

The public JSON endpoints are:

text
https://api.lever.co/v0/postings/YOUR_BOARD?mode=json
https://api.eu.lever.co/v0/postings/YOUR_BOARD?mode=json

Test both when you do not know the region. The distinction matters because an empty array is a valid success response.

On 19 Nov 2026:

  • leverdemo returned 10 jobs in 83,430 bytes from the US host.
  • Lever's own lever site returned HTTP 200 and []—just 2 bytes—from the US host.
  • The same lever site returned 6 jobs in 111,100 bytes from the EU host.
  • An unknown site returned HTTP 404 JSON: {"ok":false,"error":"Document not found"}.

That means [] is not the same as a bad site. It can mean the site belongs to the other region. The script tries the EU host when the unpinned US response is empty or 404.

2. Keep the browser request simple

Lever's GET response permits cross-origin reads, but its OPTIONS response did not send Access-Control-Allow-Origin. Adding a custom request header can make the browser send that OPTIONS preflight first, which then fails CORS.

Use this:

js
fetch(url)

Do not use this in the browser:

js
fetch(url, { headers: { Accept: 'application/json' } })

Accept: application/json looks harmless, but it can turn a working simple GET into a preflighted request. The complete script below deliberately calls fetch(url) with no options object.

3. Read the bare array correctly

Unlike APIs that wrap results in { jobs: [...] }, a successful Lever response is the array itself. A trimmed object from leverdemo looked like this on 19 Nov 2026:

json
{
  "id": "ad208490-4052-4f91-a57e-433f2d1e484b",
  "text": "Customer Success Manager",
  "categories": {
    "commitment": "Regular Full Time (Salary)",
    "department": "Customer Success",
    "location": "Atlanta, Georgia",
    "team": "Customer Success Team",
    "allLocations": ["Atlanta, Georgia"]
  },
  "workplaceType": "hybrid",
  "hostedUrl": "https://jobs.lever.co/leverdemo/ad208490-4052-4f91-a57e-433f2d1e484b",
  "createdAt": 1788199939703
}

The field names are easy to misread:

  • The visible title is text, not title.
  • Prefer categories.department, with categories.team as a fallback.
  • Prefer the array in categories.allLocations; fall back to categories.location.
  • Employment commitment is categories.commitment.
  • Workplace is the lower-case workplaceType: onsite, remote or hybrid.
  • createdAt is milliseconds since the Unix epoch, not an ISO string.
  • Link to hostedUrl. The direct application request requires company-specific information, so the hosted page is the dependable public destination.

Lever includes full descriptions and other rich fields in every posting. That is useful for a detail page but makes large boards expensive. The script maps only list fields as soon as parsing finishes.

4. Build the Webflow elements

Add these custom attributes in Element settings. Class names and nesting are yours.

ElementCustom attributeNotes
Text Fielddata-jobs = searchOptional
Selectdata-jobs = departmentStart with an empty "All departments" option
Selectdata-jobs = locationStart with an empty "All locations" option
Selectdata-jobs = workplaceStart with an empty "All workplace types" option
Text spandata-jobs = countThe script writes a number
Divdata-jobs = listRequired
↳ Link Blockdata-jobs = templateRequired fixture row
↳↳ Headingdata-job = titleLever's text field
↳↳ Textdata-job = departmentDepartment or team
↳↳ Textdata-job = locationOne or more locations
↳↳ Textdata-job = typeCommitment
↳↳ Textdata-job = workplaceNormalized workplace label
Divdata-jobs = loading"Loading open roles…"
Divdata-jobs = empty"No roles match these filters."
Divdata-jobs = errorInclude a normal hosted-board link

Make the fixture row a Link Block. Every clone will inherit its Webflow classes, hover state, icon and target setting.

5. Hide the fixture before paint

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

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

The head placement matters. If this rule is in the footer, visitors can see the dummy content for a moment while the page loads.

6. Paste the complete Lever script

Page settings → Custom code → Before </body> tag. Replace YOUR_BOARD. Leave REGION as auto unless you want to pin a known region.

html
<script>
(function () {
  const SITE = 'YOUR_BOARD'; // e.g. "leverdemo" from jobs.lever.co/leverdemo
  const REGION = 'auto'; // "auto", "us" or "eu"
  const HOSTS = {
    us: 'https://api.lever.co',
    eu: 'https://api.eu.lever.co'
  };

  const list = document.querySelector('[data-jobs="list"]');
  const template = document.querySelector('[data-jobs="template"]');
  const loading = document.querySelector('[data-jobs="loading"]');
  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"]');
  const workplaceSelect = document.querySelector('[data-jobs="workplace"]');
  if (!list || !template) return;

  const WORKPLACE = { onsite: 'On-site', remote: 'Remote', hybrid: 'Hybrid' };
  let jobs = [];

  function clean(value) {
    return typeof value === 'string' ? value.trim() : '';
  }

  function unique(values) {
    return Array.from(new Set(values.filter(Boolean)));
  }

  function safeHostedUrl(value) {
    try {
      const url = new URL(value);
      const allowedHost = url.hostname === 'jobs.lever.co' || url.hostname === 'jobs.eu.lever.co';
      const sitePath = '/' + encodeURIComponent(SITE) + '/';
      return url.protocol === 'https:' && allowedHost &&
        url.pathname.startsWith(sitePath) ? url.href : null;
    } catch (error) {
      return null;
    }
  }

  function request(region) {
    const url = HOSTS[region] + '/v0/postings/' + encodeURIComponent(SITE) + '?mode=json';
    return fetch(url).then(function (response) { // no custom headers: keep this a simple GET
      if (!response.ok) {
        const error = new Error('Lever returned ' + response.status);
        error.status = response.status;
        throw error;
      }
      return response.json();
    }).then(function (data) {
      if (!Array.isArray(data)) throw new Error('Unexpected Lever response');
      return data;
    });
  }

  function loadPostings() {
    if (REGION === 'us' || REGION === 'eu') return request(REGION);
    return request('us').then(function (data) {
      return data.length ? data : request('eu');
    }).catch(function (error) {
      if (error.status === 404) return request('eu');
      throw error;
    });
  }

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

  function render() {
    const query = clean(search && search.value).toLowerCase();
    const department = deptSelect ? deptSelect.value : '';
    const location = locSelect ? locSelect.value : '';
    const workplace = workplaceSelect ? workplaceSelect.value : '';
    const shown = jobs.filter(function (job) {
      return (!query || job.title.toLowerCase().includes(query)) &&
        (!department || job.department === department) &&
        (!location || job.locations.includes(location)) &&
        (!workplace || job.workplace === workplace);
    });

    list.querySelectorAll('[data-jobs="row"]').forEach(function (row) { row.remove(); });
    shown.forEach(function (job) {
      const row = template.cloneNode(true);
      row.setAttribute('data-jobs', 'row');
      function set(name, value) {
        const element = row.querySelector('[data-job="' + name + '"]');
        if (element) element.textContent = value;
      }
      set('title', job.title);
      set('department', job.department);
      set('location', job.locations.join(' · '));
      set('type', job.employmentType);
      set('workplace', job.workplace);
      if (row.tagName === 'A') {
        if (job.url) row.href = job.url;
        else row.removeAttribute('href');
      }
      list.appendChild(row);
    });

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

  loadPostings()
    .then(function (data) {
      jobs = data.map(function (posting) {
        const categories = posting && posting.categories || {};
        const locations = Array.isArray(categories.allLocations) && categories.allLocations.length ?
          unique(categories.allLocations.map(clean)) : unique([clean(categories.location)]);
        return {
          id: clean(posting && posting.id),
          title: clean(posting && posting.text),
          department: clean(categories.department) || clean(categories.team),
          locations: locations,
          employmentType: clean(categories.commitment),
          workplace: WORKPLACE[clean(posting && posting.workplaceType).toLowerCase()] || '',
          createdAt: Number(posting && posting.createdAt) || 0,
          url: safeHostedUrl(posting && posting.hostedUrl)
        };
      }).filter(function (job) { return job.id && job.title; });

      jobs.sort(function (a, b) { return b.createdAt - a.createdAt; });
      fillSelect(deptSelect, unique(jobs.map(function (job) { return job.department; })).sort());
      fillSelect(locSelect, unique(jobs.flatMap(function (job) { return job.locations; })).sort());
      fillSelect(workplaceSelect, unique(jobs.map(function (job) { return job.workplace; })).sort());

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

7. What the script does

  1. Makes only simple GET requests—no custom headers and no preflight.
  2. Uses the pinned region when you set one. In auto, it tries US first and retries EU when the US body is [] or the site is missing there.
  3. Validates the success shape as a bare array.
  4. Maps text, categories and millisecond createdAt values, then drops the description-rich source objects.
  5. Uses only hostedUrl and accepts it only on the HTTPS US or EU Lever jobs hosts under this site's path.
  6. Writes vendor values with textContent, fills the filters and shows your empty or error state when needed.

8. Test both region cases

Publish to the Webflow staging domain; custom code does not run fully in the Designer canvas.

First use:

js
const SITE = 'leverdemo';
const REGION = 'us';

You should see 10 jobs with the current 19 Nov 2026 response. Then verify the region fallback with:

js
const SITE = 'lever';
const REGION = 'auto';

The US request returns []; the EU retry should render 6 jobs. These public boards will change over time, so compare against the JSON rather than treating those counts as permanent fixtures.

Also check that search, each filter, the empty state and every hosted link work on desktop and mobile.

9. What this approach does not do

This is a client-rendered index, not a CMS sync. It does not create one Webflow page per role, copy descriptions into your CMS, or place JobPosting structured data on your domain. The hosted Lever page remains the job detail and application destination.

If your SEO requirement is an indexable local detail page for every role, use a server-side or Webflow CMS workflow with explicit create, update and unpublish behavior. For a live branded list, fetching the source board avoids maintaining a second copy of every job.

10. Troubleshooting

SymptomCauseFix
Browser reports a CORS preflight failureThe request added a custom headerUse plain fetch(url) with no headers
US endpoint returns []The site may live in the EU regionTry the EU host or use the auto fallback
HTTP 404 says "Document not found"The site is unknown on that hostCheck the site slug, then the other region
Titles are blankThe script reads title instead of textUse the text field
Newest sorting looks wrongcreatedAt was parsed as an ISO string or secondsTreat it as milliseconds
Some locations are missingOnly categories.location was usedPrefer categories.allLocations when present
Direct application link failsThe public apply request needs company dataLink to hostedUrl
The page is heavy on a large boardEvery posting includes rich description contentMap only list fields and avoid rendering descriptions
Dummy row flashesThe fixture CSS is in the footerMove it into the page head

I built RoleWall (https://rolewall.com) to provide this as one script tag, including automatic US/EU detection, filters, caching and load-more; the matching live integration is at https://rolewall.com/integrations/lever-webflow. The script in this guide is free to copy and adapt, with no attribution needed.

Related Lever guides