Rippling's hosted job board is a good application destination, but its public list has a shape that catches custom careers pages off guard: one job can appear in several rows, usually because it has several locations. Rendering each row directly creates duplicate cards.

The public Rippling job board API can still power a clean Webflow list. The browser-readable endpoint needs no key. A careful client fetches every page, verifies that the board did not change halfway through, merges repeated ids, then optionally enriches each unique job with employment type and creation date.

This guide builds that client and keeps the usable list visible even when a detail request fails.

What you'll build: a searchable Rippling careers list with merged locations, department and workplace filters, optional employment type, title and newest sorting, a unique-role count, and resilient loading, empty and error states.

What you need:

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

1. Find the Rippling board slug

The board slug is the path segment before /jobs:

text
https://ats.rippling.com/opendoor/jobs         → board: opendoor
https://ats.rippling.com/your-company/jobs     → board: your-company

Put it into the list endpoint:

text
https://ats.rippling.com/api/v2/board/YOUR_BOARD/jobs?page=0&pageSize=100

A wrong board returns HTTP 404 JSON:

json
{
  "error_code": "RESOURCE_NOT_FOUND",
  "message": "Job Board not found",
  "resource": null
}

The list's OPTIONS request returned 404 on 19 Nov 2026. That is fine: a plain GET does not preflight, and the GET response sent Access-Control-Allow-Origin: *. Keep the request simple.

2. Fetch the complete list before rendering

The response envelope contains items, page, pageSize, totalItems and totalPages. With a page size of 100, the live Opendoor response was 68 rows in 28,569 bytes, all on one page.

A trimmed list row looked like this:

json
{
  "department": {
    "name": "Finance",
    "displayName": "Finance"
  },
  "id": "d5fac314-4438-4463-824a-406c63126b25",
  "language": "en-US",
  "locations": [
    {
      "name": "Toronto, Canada",
      "workplaceType": "ON_SITE"
    }
  ],
  "name": "Senior Manager, Finance",
  "url": "https://ats.rippling.com/opendoor/jobs/d5fac314-4438-4463-824a-406c63126b25"
}

Do not render page zero and hope the rest arrives. A robust list should:

  1. Remember totalItems and totalPages from the first response.
  2. Request pages in order with the same page size.
  3. Reject a response whose page does not match the requested page.
  4. Abort if totals change during the read.
  5. Cap the loop at 50 pages.
  6. Render only after the collected row count equals totalItems.

That avoids quietly showing half a careers board after a network error or mid-read change.

3. Merge repeated ids

On the live 19 Nov 2026 payload, 68 rows collapsed to 52 unique jobs. Twelve ids were repeated, accounting for 28 rows. Some repeated rows had different locations; at least one repeated the same location. Merge by id, then de-duplicate location names and workplace labels inside the merged job.

The list fields are intentionally small:

  • The title is name.
  • The department is department.name.
  • Locations and workplace types are in locations.
  • The hosted destination is url.
  • Employment type and creation date are not in the list.

Map ON_SITE, REMOTE and HYBRID to "On-site", "Remote" and "Hybrid". Never render a vendor URL blindly. The script accepts only the exact HTTPS path ats.rippling.com/{board}/jobs/{id}.

4. Optionally enrich employment type and date

For a unique job id, request:

text
https://api.rippling.com/platform/api/ats/v1/board/YOUR_BOARD/jobs/JOB_ID

A trimmed live detail response for the list item above was:

json
{
  "uuid": "d5fac314-4438-4463-824a-406c63126b25",
  "name": "Senior Manager, Finance",
  "employmentType": {
    "label": "SALARIED_FT",
    "id": "Salaried, full-time"
  },
  "createdOn": "2026-11-10T08:30:32.046000-08:00"
}

Map SALARIED_FT and HOURLY_FT to "Full-time". Map SALARIED_PT and HOURLY_PT to "Part-time". For an unfamiliar value, prefer the readable employmentType.id, then turn an underscore label into normal words.

Detail responses can be much larger than list rows because they include job content. Treat them as optional enrichment: use four concurrent requests, stop an individual request after about 8 seconds, stop the batch after about 30 seconds, and never hide the list because one failed. Keep the newest sort option disabled until at least one valid createdOn value arrives.

5. Build the Designer elements

Add custom attributes in Element settings. Your Webflow classes still control the presentation.

ElementCustom attributeNotes
Text Fielddata-jobs = searchOptional
Selectdata-jobs = departmentBegin with an empty "All departments" option
Selectdata-jobs = locationBegin with an empty "All locations" option
Selectdata-jobs = workplaceBegin with an empty "All workplace types" option
Selectdata-jobs = sortAdd title and newest; disable newest initially
Text spandata-jobs = countUnique visible roles, not source rows
Divdata-jobs = listRequired
↳ Link Blockdata-jobs = templateRequired fixture row
↳↳ Headingdata-job = titleJob name
↳↳ Textdata-job = departmentMerged department labels
↳↳ Textdata-job = locationMerged unique locations
↳↳ Textdata-job = workplaceMerged workplace labels
↳↳ Textdata-job = typeFilled after detail enrichment
Divdata-jobs = loading"Loading open roles…"
Divdata-jobs = empty"No roles match these filters."
Divdata-jobs = errorInclude a normal hosted-board link

Set the sort Select options to:

html
<option value="title">A to Z</option>
<option value="newest" disabled>Newest</option>

The list renders alphabetically first. The script enables "Newest" only after detail data supplies a valid date.

6. Hide the fixture 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>

Keep this in the head. Footer CSS arrives too late to reliably prevent a flash of the dummy row.

7. Paste the complete Rippling script

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

html
<script>
(function () {
  const BOARD = 'YOUR_BOARD'; // e.g. "opendoor" from ats.rippling.com/opendoor/jobs
  const PAGE_SIZE = 100;
  const MAX_PAGES = 50;
  const WORKPLACE = { ON_SITE: 'On-site', REMOTE: 'Remote', HYBRID: 'Hybrid' };
  const EMPLOYMENT = {
    SALARIED_FT: 'Full-time', HOURLY_FT: 'Full-time',
    SALARIED_PT: 'Part-time', HOURLY_PT: 'Part-time'
  };
  const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

  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"]');
  const sortSelect = document.querySelector('[data-jobs="sort"]');
  const newestOption = sortSelect && sortSelect.querySelector('option[value="newest"]');
  if (!list || !template) return;

  let jobs = [];

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

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

  function listUrl(page) {
    const url = new URL('https://ats.rippling.com/api/v2/board/' +
      encodeURIComponent(BOARD) + '/jobs');
    url.searchParams.set('page', String(page));
    url.searchParams.set('pageSize', String(PAGE_SIZE));
    return url.href;
  }

  function safeJobUrl(value, id) {
    const expectedPath = '/' + encodeURIComponent(BOARD) + '/jobs/' + encodeURIComponent(id);
    try {
      const url = new URL(value);
      return url.protocol === 'https:' &&
        url.hostname === 'ats.rippling.com' &&
        url.pathname === expectedPath && !url.search && !url.hash ? url.href : null;
    } catch (error) {
      return null;
    }
  }

  async function fetchRows() {
    const rows = [];
    const signatures = new Set();
    let expectedPages;
    let expectedTotal;

    for (let page = 0; page < MAX_PAGES; page += 1) {
      const response = await fetch(listUrl(page));
      if (!response.ok) throw new Error('Rippling returned ' + response.status);
      const data = await response.json();
      const valid = data && Array.isArray(data.items) && data.page === page &&
        Number.isInteger(data.totalPages) && data.totalPages >= 0 && data.totalPages <= MAX_PAGES &&
        Number.isInteger(data.totalItems) && data.totalItems >= 0;
      if (!valid) throw new Error('Unexpected Rippling pagination response');

      if (page === 0) {
        expectedPages = data.totalPages;
        expectedTotal = data.totalItems;
      }
      if (data.totalPages !== expectedPages || data.totalItems !== expectedTotal) {
        throw new Error('The board changed while loading');
      }

      const signature = JSON.stringify(data.items);
      if (data.items.length && signatures.has(signature)) throw new Error('Repeated API page');
      signatures.add(signature);
      rows.push.apply(rows, data.items);

      if (page + 1 >= expectedPages) {
        if (rows.length !== expectedTotal) throw new Error('Incomplete board response');
        return rows;
      }
      if (!data.items.length) throw new Error('Unexpected empty API page');
    }
    throw new Error('Pagination safety limit reached');
  }

  function mergeRows(rows) {
    const merged = new Map();
    rows.forEach(function (row) {
      const id = clean(row && row.id);
      const title = clean(row && row.name);
      if (!UUID.test(id) || !title) return;
      if (!merged.has(id)) {
        merged.set(id, {
          id: id, title: title, departments: [], locations: [], workplace: [],
          employmentType: '', createdAt: 0,
          url: safeJobUrl(row.url, id) ||
            'https://ats.rippling.com/' + encodeURIComponent(BOARD) + '/jobs/' + encodeURIComponent(id)
        });
      }
      const job = merged.get(id);
      job.departments.push(clean(row.department && row.department.name));
      (Array.isArray(row.locations) ? row.locations : []).forEach(function (location) {
        job.locations.push(clean(location && location.name));
        job.workplace.push(WORKPLACE[clean(location && location.workplaceType)] || '');
      });
    });
    return Array.from(merged.values()).map(function (job) {
      job.departments = unique(job.departments);
      job.locations = unique(job.locations);
      job.workplace = unique(job.workplace);
      return job;
    });
  }

  function employmentName(value) {
    const label = clean(typeof value === 'string' ? value : value && value.label);
    const readable = clean(value && typeof value === 'object' ? value.id : '');
    if (EMPLOYMENT[label]) return EMPLOYMENT[label];
    if (readable) return readable;
    return label.toLowerCase().split('_').filter(Boolean).map(function (word) {
      return word.charAt(0).toUpperCase() + word.slice(1);
    }).join(' ');
  }

  async function fetchDetail(job, totalSignal) {
    const controller = new AbortController();
    const stop = function () { controller.abort(); };
    if (totalSignal.aborted) stop();
    totalSignal.addEventListener('abort', stop, { once: true });
    const timer = setTimeout(stop, 8000);
    try {
      const url = 'https://api.rippling.com/platform/api/ats/v1/board/' +
        encodeURIComponent(BOARD) + '/jobs/' + encodeURIComponent(job.id);
      const response = await fetch(url, { signal: controller.signal });
      if (!response.ok) throw new Error('Detail returned ' + response.status);
      const data = await response.json();
      if (clean(data && data.uuid).toLowerCase() !== job.id.toLowerCase()) {
        throw new Error('Detail id did not match');
      }
      job.employmentType = employmentName(data.employmentType);
      job.createdAt = Date.parse(data.createdOn) || 0;
    } finally {
      clearTimeout(timer);
      totalSignal.removeEventListener('abort', stop);
    }
  }

  async function enrichDetails() {
    const totalController = new AbortController();
    const totalTimer = setTimeout(function () { totalController.abort(); }, 30000);
    let next = 0;
    async function worker() {
      while (next < jobs.length && !totalController.signal.aborted) {
        const job = jobs[next];
        next += 1;
        try {
          await fetchDetail(job, totalController.signal);
        } catch (error) {
          // The list remains usable when an optional detail request fails.
        }
      }
    }
    try {
      await Promise.all(Array.from({ length: Math.min(4, jobs.length) }, worker));
    } finally {
      clearTimeout(totalTimer);
    }
    if (newestOption && jobs.some(function (job) { return job.createdAt; })) {
      newestOption.disabled = false;
    }
    render();
  }

  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 sort = sortSelect ? sortSelect.value : 'title';
    const shown = jobs.filter(function (job) {
      return (!query || job.title.toLowerCase().includes(query)) &&
        (!department || job.departments.includes(department)) &&
        (!location || job.locations.includes(location)) &&
        (!workplace || job.workplace.includes(workplace));
    }).slice();

    shown.sort(sort === 'newest' ? function (a, b) {
      return b.createdAt - a.createdAt || a.title.localeCompare(b.title);
    } : function (a, b) { return a.title.localeCompare(b.title); });

    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.departments.join(' · '));
      set('location', job.locations.join(' · '));
      set('workplace', job.workplace.join(' · '));
      set('type', job.employmentType);
      if (row.tagName === 'A' && job.url) row.href = job.url;
      list.appendChild(row);
    });

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

  fetchRows()
    .then(function (rows) {
      jobs = mergeRows(rows);
      fillSelect(deptSelect, unique(jobs.flatMap(function (job) { return job.departments; })).sort());
      fillSelect(locSelect, unique(jobs.flatMap(function (job) { return job.locations; })).sort());
      fillSelect(workplaceSelect, unique(jobs.flatMap(function (job) { return job.workplace; })).sort());
      [search, deptSelect, locSelect, workplaceSelect, sortSelect].forEach(function (element) {
        if (element) element.addEventListener(element === search ? 'input' : 'change', render);
      });
      if (loading) loading.style.display = 'none';
      render();
      enrichDetails();
    })
    .catch(function (error) {
      console.error('[jobs]', error);
      if (loading) loading.style.display = 'none';
      if (errorBox) errorBox.style.display = 'block';
    });
})();
</script>

8. What the script does

  1. Reads every list page into a temporary array and refuses to expose a partial or changing board.
  2. Merges rows by UUID, keeping unique departments, locations and workplace labels.
  3. Restricts every row link to the exact hosted path for this board and id.
  4. Renders the complete list immediately with textContent, so optional details do not block candidates.
  5. Enriches four unique jobs at a time with per-request and total timeouts. A failure leaves that row's employment type blank instead of removing it.
  6. Enables newest sorting only when a valid detail date is available.
  7. Filters and counts normalized jobs, not the repeated source rows.

9. Publish and test

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

Checklist:

  • The initial count matches the number of unique ids, not totalItems
  • A multi-location job appears once with every unique location
  • ON_SITE displays as "On-site"
  • Employment type appears progressively without delaying the list
  • The newest option begins disabled and becomes available after valid details arrive
  • Every link stays under https://ats.rippling.com/{your-board}/jobs/
  • A nonsense search shows the empty state
  • A wrong board slug shows the error state, with a normal link to the hosted board

10. What this approach does not do

The list is rendered in the browser. It does not create one indexable Webflow detail page per job, and it does not add JobPosting schema to your domain. Rippling remains the detail and application destination.

If each role needs a local canonical URL, synced description and structured data, use a server-side or Webflow CMS sync with explicit handling for created, changed and closed jobs. That is a different maintenance trade-off from this live list.

The detail enrichment here is deliberately best-effort. Employment type and newest sorting are useful additions, but candidates should still see the complete title, department, location and apply link when the detail service is slow.

11. Troubleshooting

SymptomCauseFix
The same job appears several timesSource rows were rendered directlyMerge all rows by id before rendering
Only the first page appearsPage zero was rendered before pagination finishedCollect and validate all pages first
The list disappears after a detail failureEnrichment was treated as requiredRender the list first and catch detail errors per job
Newest sort is wrong or emptyThe list has no creation dateKeep it disabled until createdOn arrives
Employment type shows a machine labelThe known label was not normalizedMap full-time and part-time labels, then use a readable fallback
HTTP 404 says "Job Board not found"The board slug is wrongCopy the segment before /jobs from the hosted URL
OPTIONS returns 404The browser request was forced to preflightUse a simple GET with no custom headers
A row points somewhere unexpectedVendor URLs were accepted without validationRequire the exact HTTPS board-and-id path
Dummy row flashesThe fixture rule loads too latePut the hiding CSS inside the page head

I built RoleWall (https://rolewall.com) to provide this as one script tag, including complete pagination, id merging, best-effort detail enrichment, filters and load-more; the matching live integration is at https://rolewall.com/integrations/rippling-webflow. The script in this guide is free to copy and adapt, with no attribution needed.

Related Rippling guides