> For the complete documentation index, see [llms.txt](https://docs.anedot.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.anedot.com/integrations/crm-donor-management/kindful.md).

# Kindful

Connect Anedot to Kindful to send contacts and donation data from your Action Pages, manage your connection, and review field mapping and payload data.

The **Kindful** integration sends contacts and donation data from your Action Pages to Kindful, donor management software for nonprofits, and lives in **Settings > Integrations**. This article covers how to connect Anedot to Kindful, manage your connection, review what Anedot sends, find your data in Kindful, and review field mapping, payload data, and troubleshooting.

## Before You Begin

* You need **Integrations: Edit permissions** to add, edit, push or delete a connection. Integrations: Edit permissions also require **Action Pages: View permissions** and **Integrations: View permissions**. See [Permission Sets](https://docs.anedot.com/settings/access/permission-sets.md).
* You need API access in Kindful. When your Kindful account has API access, **Custom Apps** appears in the **Apps** section of your Kindful Admin account.
* If **Custom Apps** isn't visible, email <support@kindful.com> to request access to Kindful's API.
* You need a Kindful Application Token. You'll generate it in Step 1 below.

## Connect Anedot to Kindful

### Step 1: Get Your Kindful Application Token

To get your Application Token:

1. Log in to your Kindful Admin area.
2. Go to **Apps > Custom Apps**.
3. Click **Create a new application**.
4. Enter a name for the app.
5. (Optional) Enter a description.
6. Click **Create Application**. Kindful opens the Production dashboard for the app.
7. Click **Generate security token/Manage Credentials**.
8. Copy the Application Token.

Your Application Token is ready to enter in Anedot.

{% hint style="warning" %}
Regenerating the Application Token in Kindful breaks your connection until the token is updated. To use a new token in Anedot, delete the connection and connect again.
{% endhint %}

### Step 2: Create the Connection in Anedot

To create the connection:

1. Go to **Settings > Integrations**.
2. Click **New integration**.
3. Choose **Kindful**. The card is in the CRM category and is described as "Send Action Page data to Kindful."
4. Choose which Action Pages to include:
   * Leave **All Action Pages** checked to include all current and future pages. (Optional) In **Exclude Pages**, enter a comma separated list of Action Page IDs, with no spaces, to leave those pages out.
   * Uncheck **All Action Pages** and choose pages in **Selected pages** to include only the pages you pick.
5. Leave **Team** set to **All teams**.
6. Enter your Kindful Application Token in **Token**.
7. Click **Create integration**.

Anedot shows "Integration created." and the connection appears in your list of integrations. Nothing is sent to Kindful when you create the connection. Anedot starts sending records with the next qualifying submission.

{% hint style="info" %}
If you uncheck **All Action Pages** without choosing a page, Anedot shows "Select at least one Action Page, or choose All Action Pages." If your Action Pages are still loading, wait a moment and try again.
{% endhint %}

## Manage Your Connection

Each Kindful connection in **Settings > Integrations** has **Edit**, **Push unsent**, and **Delete** buttons.

### Edit A Connection

After you create the connection, the list may show **Integration** followed by the connection ID, for example "Integration 42", until you enter a **Name** in **Edit**.

To edit a connection:

1. Go to **Settings > Integrations**.
2. Click **Edit** on the Kindful connection.
3. (Optional) Update your Action Page selection.
4. Leave **Team** set to **All teams**.
5. Enter a **Name** for the connection. **Name** is required to save.
6. Leave the **Credentials/details JSON** box as it is.
7. Click **Save integration**.

Anedot shows "Integration updated." and saves your changes. The **Provider** field shows `kindful` and can't be changed.

{% hint style="info" %}
Your Token isn't shown or changed in **Edit**. To use a different Token, delete the connection and connect again.
{% endhint %}

### Push Unsent Records

**Push unsent** sends submissions and successful recurring charges in a date range that haven't already been successfully sent to Kindful. Records that were sent successfully aren't sent again.

When you push unsent records:

* The **Start date** and **End date** range can be up to 31 days.
* The **Start date** must be within the last 12 months.
* Wait about five minutes between pushes.

When the push begins, Anedot shows "Push started." For the full steps, see [Push Unsent](https://docs.anedot.com/integrations/integration-automation-tools/webhooks.md#push-unsent) in Webhooks (API).

### Delete A Connection

To stop sending records to Kindful, delete the connection.

To delete a connection:

1. Go to **Settings > Integrations**.
2. Click **Delete** on the Kindful connection.
3. Confirm "Delete this integration?"

Anedot shows "Integration deleted." and stops sending records to Kindful. Records already in Kindful aren't changed.

{% hint style="danger" %}
Deleting a connection can't be undone. To send records to Kindful again, connect again.
{% endhint %}

## Data Relays

### What Anedot Sends

* **Lead Pages:** Anedot sends a contact when the submission is created. `data_format` is `contact`, and no transaction keys are sent.
* **Donation Pages:** Anedot sends a contact with a transaction when the payment is completed. `data_format` is `contact_with_transaction`.
* **Paid Event Pages:** Anedot sends a contact with a transaction when the payment is completed, the same as Donation Pages.
* **Free Event registrations:** Anedot sends these too.
* **Recurring donations:** Anedot sends each successful recurring charge as its own transaction. Recurring frequency isn't sent.
* **Multi-fund gifts:** Anedot sends one request for the submission or charge, using the total amount.

Kindful matches contacts by email (`match_by` is `{"contact":"email"}`). `action_type` is `update` and `data_type` is `json`. Amounts are sent as an integer in cents in `amount_in_cents`, so a $25.00 gift is sent as `2500`.

`transaction_type` is `credit_card`, `bank_account`, `paypal`, `bitcoin_open_node`, or null. Apple Pay and Google Pay are sent as `credit_card`.

### Records Anedot Skips

Anedot doesn't send these to Kindful, and no row is created in **Settings > Integration Requests** when a record is skipped:

* Refunds, voids, chargebacks, ACH returns, and settled events
* Abandoned Actions
* Later edits to a submission that was already sent
* Commitment changes, such as a cancellation
* A donation whose payment isn't completed yet. Anedot sends it when the payment completes.
* A Donation Page submission with no donations
* Records for a deleted connection

These fields aren't sent: custom fields, hidden fields, UTM values, country, fund, occupation, middle name, and recurring frequency.

### Delivery And Retries

Every attempt to send a record to Kindful appears in **Settings > Integration Requests**. Each row shows the request body, request headers, response body, and response status. See [Integration Requests](https://docs.anedot.com/integrations/relay-data-troubleshooting/integration-requests.md).

* **Success:** Kindful responded with HTTP 200.
* **Failure:** Kindful responded with any other HTTP status. Fix the cause, then use **Push unsent**.
* **Error:** Anedot couldn't complete the request. The row may show "No HTTP status." These attempts can be tried again automatically.

## Find Your Data in Kindful

To confirm a record left Anedot, look for its Success row in **Settings > Integration Requests**.

After Anedot sends a record, review **Import Jobs** on your custom app's Production dashboard in Kindful. You can sort the table by date and status, and click the Job ID for more details. What Kindful does with a record after it accepts it is set by Kindful.

{% hint style="info" %}
A Kindful response with `"status": "pending"` and HTTP 200 is a Success row in Anedot.
{% endhint %}

## Field Mapping

Top-level request fields:

| Anedot Value                                                   | Kindful Field                |
| -------------------------------------------------------------- | ---------------------------- |
| `contact` for Lead Pages; `contact_with_transaction` otherwise | `data_format`                |
| `update`                                                       | `action_type`                |
| Contact matched by email                                       | `match_by.contact` (`email`) |
| `json`                                                         | `data_type`                  |

Contact fields in `data[0]`:

| Anedot Value               | Kindful Field   |
| -------------------------- | --------------- |
| First name                 | `first_name`    |
| Last name                  | `last_name`     |
| Email                      | `email`         |
| Phone                      | `primary_phone` |
| Employer name              | `company_name`  |
| Address line 1             | `addr1`         |
| Address line 2             | `addr2`         |
| City                       | `city`          |
| State / region             | `state`         |
| Postal code                | `postal`        |
| Date updated, UTC ISO 8601 | `updated_at`    |
| Action Page UUID           | `campaign_id`   |
| Action Page name           | `campaign`      |

Transaction fields in `data[0]` (not sent for Lead Pages):

| Anedot Value                                                                           | Kindful Field            |
| -------------------------------------------------------------------------------------- | ------------------------ |
| Total amount as an integer in cents, for example `2500` for $25.00                     | `amount_in_cents`        |
| Submission or recurring-charge UUID                                                    | `transaction_id`         |
| Payment method (`credit_card`, `bank_account`, `paypal`, `bitcoin_open_node`, or null) | `transaction_type`       |
| Transaction date updated, UTC ISO 8601                                                 | `transaction_updated_at` |

## Payload Data

This example is a `contact_with_transaction` request body for a $25.00 one-time card donation from Annie Dot, as shown in **Settings > Integration Requests**. Values in angle brackets are placeholders.

```json
{
  "data_format": "contact_with_transaction",
  "action_type": "update",
  "match_by": {
    "contact": "email"
  },
  "data_type": "json",
  "data": [
    {
      "first_name": "Annie",
      "last_name": "Dot",
      "email": "annie.dot@example.com",
      "primary_phone": "2255550123",
      "company_name": null,
      "addr1": "123 Main St",
      "addr2": null,
      "city": "Baton Rouge",
      "state": "LA",
      "postal": "70801",
      "updated_at": "2026-11-12T15:04:05Z",
      "campaign_id": "<action page UUID>",
      "campaign": "<Action Page name>",
      "amount_in_cents": 2500,
      "transaction_id": "<submission UUID>",
      "transaction_type": "credit_card",
      "transaction_updated_at": "2026-11-12T15:04:05Z"
    }
  ]
}
```

For a Lead Page, `data_format` is `contact`, and the `amount_in_cents` and `transaction_*` keys are omitted.

A successful response from Kindful (HTTP 200) looks like this:

```json
{
  "id": "<import UUID>",
  "status": "pending"
}
```

## Troubleshooting

### A Record Isn't in Kindful

Go to **Settings > Integration Requests** and look for a row for the record. Confirm the page type and that the page is included in your Action Page selection. If you expect a transaction, confirm the payment completed. Lead Pages are sent as contacts with no transaction keys.

### A Row Shows Failure

Review the response body and status in the row, fix the cause, then use **Push unsent** to send the record again.

### A Row Shows Error

Anedot couldn't complete the request. These attempts can be tried again automatically.

### A Success Row Shows a Pending Status

A response with `"status": "pending"` and HTTP 200 is a successful send from Anedot. Review **Import Jobs** in Kindful to find the import.

### You Need to Use a Different Token

Delete the connection and connect again with the new Application Token.

If the issue continues, contact our Support team at <help@anedot.com>.

## Related Articles

* [Integrations](https://docs.anedot.com/integrations.md)
* [Integration Requests](https://docs.anedot.com/integrations/relay-data-troubleshooting/integration-requests.md)
* [Webhooks (API)](https://docs.anedot.com/integrations/integration-automation-tools/webhooks.md)
* [Permission Sets](https://docs.anedot.com/settings/access/permission-sets.md)
* [Teams](https://docs.anedot.com/settings/access/teams.md)
* [Commitments](https://docs.anedot.com/finance/management-and-reporting/commitments.md)
* [CRM & Donor Management](https://docs.anedot.com/integrations/crm-donor-management.md)


---

# 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.anedot.com/integrations/crm-donor-management/kindful.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.
