Ashby gives you a polished hosted job board. You can link to it, but an embed or vendor page does not become part of your Webflow design. Your Webflow classes cannot control the typography, spacing and responsive behavior inside a document served from another domain.

There is another option. Ashby's public posting API needs no key, and its responses allow browser requests from any origin. A Webflow page can fetch the open roles, clone a Link Block you designed, and fill it with safe text.

This guide builds that version and fixes a common rough edge: the dummy template row flashing before JavaScript replaces it.

What you'll build: a searchable Ashby careers list with department, location and workplace filters, an open-role count, an empty state and an error fallback. Every row links to the hosted Ashby job page.

What you need:

  • A public Ashby board such as jobs.ashbyhq.com/your-company
  • A Webflow plan that permits page-level custom code
  • One job row designed in the Webflow Designer
  • No API key, Zapier, Make or CMS collection

1. Find your Ashby board slug

Open the hosted board. The first path segment is the board slug:

text
https://jobs.ashbyhq.com/linear          → board: linear
https://jobs.ashbyhq.com/your-company    → board: your-company

Put that value into the public endpoint:

text
https://api.ashbyhq.com/posting-api/job-board/YOUR_BOARD

A valid response is an object with jobs and apiVersion. A wrong slug returns HTTP 404 as text/plain with the body Not Found. That response means the slug is wrong; it is not a JSON parsing or CORS problem.

If a command-line request receives Cloudflare error 1010, retry with a normal browser user agent. The endpoint works from browsers, and its GET response sends Access-Control-Allow-Origin: *. Its OPTIONS response returned 204 with Access-Control-Allow-Methods: GET on 19 Nov 2026.

2. Understand the response and its weight

Ashby returns everything in one request: list fields, application URLs and both HTML and plain-text descriptions. On 19 Nov 2026, Linear's public board returned 32 jobs in 448,777 bytes.

A trimmed live object looked like this:

json
{
  "id": "d3bc1ced-3ce4-4086-a050-555055dbb1ff",
  "title": "Senior / Staff Fullstack Engineer",
  "department": "Product",
  "team": "Engineering",
  "employmentType": "FullTime",
  "location": "Europe",
  "secondaryLocations": [],
  "workplaceType": "Remote",
  "isRemote": true,
  "publishedAt": "2021-04-27T20:13:45.158+00:00",
  "jobUrl": "https://jobs.ashbyhq.com/linear/d3bc1ced-3ce4-4086-a050-555055dbb1ff",
  "applyUrl": "https://jobs.ashbyhq.com/linear/d3bc1ced-3ce4-4086-a050-555055dbb1ff/application"
}

The fields that matter for a list are:

  • title
  • department, with team as a fallback
  • location plus each secondaryLocations[].location
  • employmentType
  • workplaceType, with isRemote as a fallback
  • publishedAt
  • jobUrl, then applyUrl as a fallback

Skip a record when isListed === false. Do not keep descriptionHtml or descriptionPlain after you normalize the list. Description-rich boards can be much larger than their job count suggests, and a careers index does not need that content.

Normalize the machine labels before showing them to visitors. The script below maps FullTime to "Full-time", PartTime to "Part-time", Intern to "Internship" and OnSite to "On-site".

3. Build the row and filters in the Designer

The script finds custom attributes, not class names. Your classes, nesting and responsive styles remain up to you.

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 list wrapper
↳ Link Blockdata-jobs = templateRequired; design this with dummy content
↳↳ Headingdata-job = titleFilled with textContent
↳↳ Textdata-job = departmentDepartment or team
↳↳ Textdata-job = locationPrimary and secondary locations
↳↳ Textdata-job = typeNormalized employment type
↳↳ Textdata-job = workplaceRemote, Hybrid or On-site
Divdata-jobs = loading"Loading open roles…"
Divdata-jobs = empty"No roles match these filters."
Divdata-jobs = errorInclude a normal link to the hosted board

Make the template a Link Block so the cloned row is clickable. Add target="_blank" in the Designer if you want hosted job pages to open in a new tab.

4. Stop the dummy row from flashing

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

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

This rule must be in the head so the browser sees it before the first paint. The script changes each clone from template to row, so real jobs are visible. It never removes the original fixture; you can keep editing that row in the Designer.

5. Paste the complete Ashby script

Page settings → Custom code → Before </body> tag. Replace YOUR_BOARD:

html
<script>
(function () {
  const BOARD = 'YOUR_BOARD'; // e.g. "linear" from jobs.ashbyhq.com/linear
  const API = 'https://api.ashbyhq.com/posting-api/job-board/' + encodeURIComponent(BOARD);

  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 EMPLOYMENT = {
    FullTime: 'Full-time', PartTime: 'Part-time', Intern: 'Internship',
    Contract: 'Contract', Temporary: 'Temporary'
  };
  const WORKPLACE = { OnSite: 'On-site', Remote: 'Remote', Hybrid: 'Hybrid' };
  let jobs = [];

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

  function safeJobUrl(value) {
    try {
      const url = new URL(value);
      const boardPath = '/' + encodeURIComponent(BOARD) + '/';
      return url.protocol === 'https:' &&
        url.hostname === 'jobs.ashbyhq.com' &&
        url.pathname.startsWith(boardPath) ? url.href : null;
    } catch (error) {
      return null;
    }
  }

  function employmentName(value) {
    const raw = clean(value);
    if (!raw) return '';
    return EMPLOYMENT[raw] || raw;
  }

  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 unique(values) {
    return Array.from(new Set(values.filter(Boolean)));
  }

  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';
  }

  fetch(API)
    .then(function (response) {
      if (!response.ok) throw new Error('Ashby returned ' + response.status);
      return response.json();
    })
    .then(function (data) {
      if (!data || !Array.isArray(data.jobs)) throw new Error('Unexpected Ashby response');
      jobs = data.jobs.filter(function (posting) {
        return posting && posting.isListed !== false;
      }).map(function (posting) {
        const locations = unique([
          clean(posting.location)
        ].concat(Array.isArray(posting.secondaryLocations) ?
          posting.secondaryLocations.map(function (entry) { return clean(entry && entry.location); }) : []));
        const workplace = WORKPLACE[clean(posting.workplaceType)] ||
          (posting.isRemote === true ? 'Remote' : '');
        return {
          id: clean(posting.id),
          title: clean(posting.title),
          department: clean(posting.department) || clean(posting.team),
          locations: locations,
          employmentType: employmentName(posting.employmentType),
          workplace: workplace,
          publishedAt: Date.parse(posting.publishedAt) || 0,
          url: safeJobUrl(posting.jobUrl) || safeJobUrl(posting.applyUrl)
        };
      }).filter(function (job) { return job.id && job.title; });

      jobs.sort(function (a, b) { return b.publishedAt - a.publishedAt; });
      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>

6. What the script does

  1. Fetches the public board once with no key or cookies.
  2. Ignores unlisted records and immediately maps the rich response to small list objects, leaving both description fields behind.
  3. Combines primary and secondary locations, normalizes employment and workplace labels, then sorts by publishedAt.
  4. Accepts links only when they use HTTPS, the jobs.ashbyhq.com host and this board's path.
  5. Clones the Designer fixture and writes every vendor value with textContent. It never injects description HTML into the list.
  6. Fills real filter options and re-renders on search or filter changes.
  7. Leaves a hosted-board link available in the error state when the API or slug fails.

7. Publish and test

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

Checklist:

  • The count matches the number of listed jobs in the JSON
  • A role with secondary locations shows each one once
  • FullTime appears as "Full-time" and OnSite appears as "On-site"
  • Every row opens a URL under your own Ashby board path
  • A nonsense search shows the empty state
  • A deliberately wrong board slug shows the error state; restore it afterward
  • The dummy row never flashes during a hard refresh

8. What this approach does not do

The job list is client-rendered. Search engines can render JavaScript, but this setup does not create a separate indexable page on your domain for each role. The canonical job pages and their application flow remain on Ashby.

If every role needs its own Webflow URL and JobPosting structured data on your domain, build a server-side or Webflow CMS sync. That introduces create, update and unpublish logic that this lightweight list intentionally avoids.

For most careers indexes, an on-brand live list plus hosted applications is the simpler balance: a recruiter closes a role in Ashby, and it disappears on the next page load without a second database to reconcile.

9. Troubleshooting

SymptomCauseFix
Dummy row flashesThe hiding rule loads after the bodyPut the CSS in the page head
HTTP 404 with Not FoundThe board slug is wrongCopy the first path segment after jobs.ashbyhq.com
Command-line probe gets error 1010Cloudflare rejected the user agentRetry with a normal browser user agent
Some roles are missingThey have isListed: false or are not publishedCheck the role's external publishing settings in Ashby
Department is blankThe posting has neither department nor teamFill one in Ashby or change the fallback copy
A location is missingSecondary locations are nested objectsRead each secondaryLocations[].location as the script does
A row has no linkThe returned URL did not match the trusted board pathInspect jobUrl, applyUrl and the BOARD value
Page feels heavy on a large boardThe response includes full descriptionsKeep only normalized list fields and avoid rendering descriptions

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

Related Ashby guides