> For the complete documentation index, see [llms.txt](https://docs.coupler.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.coupler.io/sources/category/other/ashby.md).

# Ashby

Export Ashby candidates, applications, jobs, and offers to Google Sheets, Excel, or BigQuery. Manage recruiting pipelines and hiring workflows via Coupler.io.

Ashby is an all-in-one recruiting platform that helps talent teams manage job openings, candidates, interview pipelines, and offers in one place. It's built for high-growth companies that need structured hiring workflows and detailed reporting. Connecting Ashby to Coupler.io lets you pull your recruiting data into any destination for analysis, reporting, or automation.

**Why connect Ashby to Coupler.io?**

* Export candidates, applications, jobs, and offers to Google Sheets, Excel, BigQuery, or Looker Studio for custom recruiting dashboards
* Combine multiple Ashby entities — for example, join Applications with Candidates or Jobs to get a full picture of your pipeline
* Send recruiting data to AI tools like ChatGPT, Claude, or Gemini to generate summaries, spot trends, or draft reports
* Keep your data fresh with scheduled syncs so your reports always reflect the latest hiring activity

## Prerequisites

Before connecting, make sure you have:

* An active Ashby account with **admin access** (required to generate an API key)
* An Ashby API key — you can generate one in your Ashby account under **Settings → Integrations → API Keys**

## Quick start

{% hint style="success" %}
Start with the **Applications** entity joined with **Candidates** and **Jobs** — this combination gives you the most complete view of your hiring pipeline right away.
{% endhint %}

## How to connect

{% stepper %}
{% step %}
**Create a new data flow in Coupler.io.** Log in to Coupler.io, go to the Data Flows section, and click **Add data flow**. Search for Ashby and select it as your source.
{% endstep %}

{% step %}
**Enter your Ashby API key.** In the source settings, paste your API key into the API key field. You can find this in Ashby under **Settings → Integrations → API Keys**. If you haven't created one yet, click **Add API Key**, give it a name, and copy the generated key.
{% endstep %}

{% step %}
**Select an entity.** Choose which data you want to export — for example, Applications, Candidates, Jobs, or Offers. You can add more sources to the same data flow to pull multiple entities at once.
{% endstep %}

{% step %}
**Choose a destination.** Select where you want your data to go — Google Sheets, Excel, BigQuery, Looker Studio, or an AI destination like ChatGPT, Claude, or Gemini.
{% endstep %}

{% step %}
**Run your data flow.** Click **Run** to execute a manual sync and confirm data is loading correctly. Once it completes successfully, you're all set.
{% endstep %}
{% endstepper %}

## Ashby data overview

Ashby exposes a wide range of recruiting data through Coupler.io — from top-of-funnel candidate sourcing all the way through to offer management. You can pull structured data about every stage of your hiring process and combine entities to build meaningful reports.

## Available entities

| Entity                    | Best used for                                                |
| ------------------------- | ------------------------------------------------------------ |
| Applications              | Pipeline tracking, stage conversion rates, time-to-hire      |
| Candidates                | Talent pool analysis, source attribution, diversity tracking |
| Jobs                      | Open requisitions, headcount planning                        |
| Job postings              | Career page coverage, job board distribution                 |
| Offers                    | Offer acceptance rates, compensation benchmarking            |
| Interview schedules       | Interviewer workload, scheduling efficiency                  |
| Feedback form definitions | Interview process consistency                                |
| Archive reasons           | Rejection analysis, pipeline quality                         |
| Sources                   | Source-of-hire reporting                                     |
| Departments               | Hiring by team or org unit                                   |
| Locations                 | Hiring by office or region                                   |
| Candidate tags            | Talent segmentation                                          |
| Custom fields             | Any additional structured data your team has configured      |
| Users                     | Recruiter activity and workload                              |

## Key fields by entity

#### Applications

| Field          | Description                                          |
| -------------- | ---------------------------------------------------- |
| Application ID | Unique identifier for the application                |
| Candidate ID   | Links to the candidate record                        |
| Job ID         | Links to the job requisition                         |
| Status         | Current application status (active, archived, hired) |
| Current stage  | The interview stage the application is in            |
| Created at     | When the application was submitted                   |
| Updated at     | Last update timestamp                                |
| Archive reason | Reason for rejection if applicable                   |
| Source         | How the candidate was sourced                        |

#### Candidates

| Field        | Description                    |
| ------------ | ------------------------------ |
| Candidate ID | Unique identifier              |
| Name         | Full name                      |
| Email        | Primary contact email          |
| Phone        | Contact phone number           |
| Tags         | Applied candidate tags         |
| Created at   | When the candidate was added   |
| Source       | Origin of the candidate record |

#### Jobs

| Field      | Description                     |
| ---------- | ------------------------------- |
| Job ID     | Unique identifier               |
| Title      | Job title                       |
| Department | Associated department           |
| Location   | Office or remote designation    |
| Status     | Open, closed, or draft          |
| Created at | When the requisition was opened |

#### Offers

| Field          | Description                               |
| -------------- | ----------------------------------------- |
| Offer ID       | Unique identifier                         |
| Application ID | Links to the application                  |
| Status         | Pending, accepted, declined, or rescinded |
| Created at     | When the offer was extended               |

#### Interview schedules

| Field          | Description                     |
| -------------- | ------------------------------- |
| Schedule ID    | Unique identifier               |
| Application ID | Links to the application        |
| Start time     | Scheduled interview start       |
| End time       | Scheduled interview end         |
| Interviewers   | Users assigned to the interview |

## Common field combinations

These joins across entities are especially useful for recruiting analytics:

* **Applications + Candidates + Jobs** — full pipeline view with candidate details and role context
* **Applications + Sources** — source-of-hire analysis to see which channels produce the most applicants
* **Applications + Archive reasons** — rejection analysis to understand where candidates drop off
* **Offers + Applications** — offer acceptance rate by role, department, or source
* **Interview schedules + Users** — interviewer workload and scheduling patterns

Use the **Join** transformation in Coupler.io to combine these entities in a single data flow.

## Use cases by role

{% tabs %}
{% tab title="Talent acquisition" %}

* Track pipeline conversion rates from application to offer by stage
* Measure time-to-hire and time-in-stage for each job opening
* Analyze which sources (job boards, referrals, events) produce the most hires
* Monitor offer acceptance rates and spot patterns in declines
  {% endtab %}

{% tab title="People & HR" %}

* Report on hiring velocity by department and location
* Track headcount growth against open requisitions
* Audit archive reasons to identify bias or process gaps
* Use custom fields data to capture and analyze structured interview feedback
  {% endtab %}

{% tab title="Hiring managers" %}

* See real-time status of candidates for their open roles
* Review scheduled interviews and feedback form completion
* Get a snapshot of how many candidates are at each stage of their pipeline
  {% endtab %}

{% tab title="Finance & ops" %}

* Forecast headcount costs using open jobs and offer data
* Track recruiting spend per hire by combining source data with hiring outcomes
* Align hiring timelines with budget cycles using requisition and offer timestamps
  {% endtab %}
  {% endtabs %}

## Platform-specific notes

* The **start date** parameter filters records based on their creation or update timestamp — use it to limit large exports to a recent window
* **Custom fields** appear as separate columns in your export; field names reflect what your team configured in Ashby
* **Archive reasons** and **candidate tags** are lookup tables — join them to Applications or Candidates to get human-readable labels
* User records include recruiters and hiring managers but may not reflect deactivated accounts in all cases
* Ashby's API returns data in pages; Coupler.io handles pagination automatically so you always get complete results

## Ashby common issues

### Connection issues

<details>

<summary>My API key is rejected and the connection fails</summary>

Double-check that you copied the full API key from Ashby without any trailing spaces. API keys are generated under **Settings → Integrations → API Keys** — make sure you're using a key from this section and not a webhook secret or another credential. If the key was created for a limited integration scope, it may not have permission to access all entities. Try generating a new key with full access.

</details>

<details>

<summary>The data flow connects but returns no data</summary>

If the connection succeeds but the export is empty, check your **start date** parameter. If you've set a start date that's in the future or very recent, no records will match. Try clearing the start date to export all available data and confirm there are records in Ashby for the selected entity.

</details>

### Missing data

<details>

<summary>Some candidates or applications are missing from the export</summary>

Ashby's API may not return archived or deleted records depending on the entity and your account configuration. Check whether the missing records have been archived in Ashby. Also verify your start date filter — records created before the start date won't be included.

</details>

<details>

<summary>Custom fields are not appearing in my export</summary>

Custom fields only appear if they have been populated on at least some records. If a custom field exists in Ashby but has no values, it may not show up as a column. Try exporting the **Custom fields** entity separately to see all defined fields, then cross-reference with your Candidates or Applications data.

</details>

<details>

<summary>Interview schedules show incomplete data</summary>

Interview schedules are tied to specific applications. If an interview was cancelled or the application was archived before the schedule was confirmed, it may appear incomplete. Check the application status in Ashby to confirm the record is in the expected state.

</details>

### Permission errors

<details>

<summary>I get a 403 or "unauthorized" error when running the data flow</summary>

This usually means your API key doesn't have sufficient permissions. In Ashby, API key permissions can be scoped — ask your Ashby admin to verify the key has read access to the entities you're trying to export. If you're not the account admin, you may need to request a new key with broader access.

</details>

### Data discrepancies

<details>

<summary>Counts in Coupler.io don't match what I see in Ashby reports</summary>

Ashby's built-in reports may apply default filters (e.g., only active jobs, only specific date ranges) that differ from a raw API export. Coupler.io pulls unfiltered data unless you set a start date. Compare the raw record count in your export against Ashby with all filters removed to check for alignment.

</details>

### Rate limits

<details>

<summary>My data flow times out or returns partial data on large exports</summary>

Ashby's API enforces rate limits that may slow down large exports. Coupler.io handles pagination automatically, but very large datasets (e.g., thousands of candidates with full history) may take longer to complete. If you're hitting consistent issues, try narrowing your export using the start date parameter to pull data in smaller windows.

</details>

## Ashby FAQ

<details>

<summary>Where do I find my Ashby API key?</summary>

Go to **Settings → Integrations → API Keys** in your Ashby account. Click **Add API Key**, give it a descriptive name (e.g., "Coupler.io integration"), and copy the key that's generated. You need admin access to create API keys — if you don't see this option, ask your Ashby administrator.

</details>

<details>

<summary>Can I export data from multiple Ashby accounts into one destination?</summary>

Yes. Add multiple sources to the same data flow — one for each Ashby account using its own API key. Use the **Append** transformation to stack the data into a single table in your destination, with a column to identify which account each row came from.

</details>

<details>

<summary>Why does the Applications entity show different numbers than Ashby's pipeline reports?</summary>

Ashby's built-in reports apply filters by default — for example, they may only show active applications or exclude certain stages. Coupler.io exports all records matching your start date filter without additional filtering. Remove all filters in Ashby's report view to compare like-for-like.

</details>

<details>

<summary>Can I track how application statuses change over time?</summary>

The Ashby API returns the current state of each record, not a changelog. To track changes over time, use the **Append** transformation in Coupler.io so each scheduled run adds a new snapshot of your data. Comparing snapshots lets you calculate things like time-in-stage or identify when offers were accepted or declined.

</details>

<details>

<summary>What's the best way to analyze source-of-hire from Ashby data?</summary>

Export both the **Applications** and **Sources** entities, then use the **Join** transformation to connect them on the source ID field. This gives you application counts broken down by source name, which you can then filter by job, department, or hire status in your destination.

</details>

<details>

<summary>Can I use Ashby data with AI tools?</summary>

Yes. Coupler.io supports AI destinations including ChatGPT, Claude, Gemini, Cursor, Perplexity, and OpenClaw. You can send your recruiting data — such as candidate feedback, archive reason patterns, or offer outcomes — directly to these tools for summarization, trend analysis, or report drafting.

</details>

<details>

<summary>Does Coupler.io support all custom fields I've created in Ashby?</summary>

Yes, as long as those custom fields have values populated on at least some records. Export the **Custom fields** entity to see all defined fields, then look for those fields as columns in your Candidates, Applications, or Jobs exports. Fields with no populated values may not appear as columns.

</details>

{% hint style="info" %}
For details on what data each entity contains, see the [Data Overview](#ashby-data-overview) article. If you're running into connection or data problems, check [Common Issues](#ashby-common-issues). For tips on structuring your data flow efficiently, visit [Best Practices](https://docs.coupler.io/sources/category/other/ashby/best-practices.md).
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.coupler.io/sources/category/other/ashby.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
