# Charity & Nonprofit Lookup API (GiveRadar, 100+ countries) (`giveradar/charity-nonprofit-lookup`) Actor

Look up charities and nonprofits in 100+ countries by name, profile or registration number (EIN, charity number) with your own GiveRadar API key. Integrity score, registry IDs, red flags; financials on Pro.

- **URL**: https://apify.com/giveradar/charity-nonprofit-lookup.md
- **Developed by:** [GiveRadar](https://apify.com/giveradar) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Charity & Nonprofit Lookup API: 7.9M+ nonprofits in 100+ countries

Look up any charity or nonprofit by name, by GiveRadar profile, or by its registration number, and get structured JSON back: registry identifiers, category, location, website, the GiveRadar integrity assessment, red flags and, on a Pro key, financials, filing history and officers. The data comes from [GiveRadar](https://giveradar.com/), a free charity intelligence platform built on official government registries and tax authorities in most of the countries it covers.

This Actor is a thin client. It calls the GiveRadar API with **your own GiveRadar API key** and saves the answers to this run's dataset. Nothing else is stored, and every request counts against your key's daily quota.

#### What you can do with it

- **Search charities by name**: one query or a list of hundreds, optionally filtered by country (`GB`, `US`, `NL`, `CA`, `AU` and so on). A US EIN such as `13-1624100` works as a query too.
- **Verify a registration number**: give `GB:202918` or `US:131624100` and get back the organization registered under that number, if GiveRadar holds it. Useful for donation platforms, grant tools and KYB checks.
- **Fetch full profiles**: pass GiveRadar slugs (the last part of a profile URL, such as `oxfam-202918`) and get the complete record.
- **Add filing history and news**: optional extras per charity. Filing history needs a Pro key.

#### Who uses charity data like this

- Grantmakers and foundations screening applicants before a grant.
- Donation platforms and fintechs checking that a payee is a registered nonprofit.
- Researchers and journalists who need the same fields across many countries.
- CRM and fundraising tools enriching nonprofit records with registry IDs and websites.
- AI agents that need a structured source instead of scraping registry websites.

#### Coverage

GiveRadar holds 7.9M+ nonprofit records across 100+ countries. Most countries come straight from the national regulator or tax authority, for example the IRS Exempt Organizations Master File and Form 990 filings (United States), the Charity Commission for England and Wales, OSCR and CCNI (United Kingdom), the ACNC (Australia), the CRA T3010 returns (Canada) and the Belastingdienst ANBI register (Netherlands). A small number of countries come from curated directories instead of a government register, and GiveRadar labels them that way. The [data sources page](https://giveradar.com/data-sources/) lists every source per country.

Records that GiveRadar has excluded (duplicates, organizations that are not charities) are not returned by the API.

#### Free key vs Pro key

| | Free key | Pro key |
|---|---|---|
| Requests per day | 10 | 10,000 |
| Price | Free | $99/month, billed by GiveRadar |
| Name, country, category, integrity score | Yes | Yes |
| Description, website, city, registry IDs, red flags | Yes | Yes |
| Revenue, expenses, assets and liabilities | No (null) | Yes |
| Officers and executive pay, email, phone, address | No (null) | Yes |
| Filing history (`includeFinancials`) | No | Up to 10 years |

The Actor itself is free. You pay Apify only for the small amount of platform usage a run takes, and GiveRadar for a Pro key if you need one. [Create a GiveRadar API key](https://giveradar.com/api/) in a minute: the free tier needs no credit card.

**Note for Free keys:** GiveRadar also limits free-tier traffic to 10 requests a day per IP address across all free keys. Apify runs share outbound IP addresses, so a free key can occasionally hit that limit early on Apify. The free tier is meant for testing; use a Pro key for real workloads.

#### Input

| Field | Used in | What it does |
|---|---|---|
| `apiKey` | all | Your GiveRadar API key (starts with `gr_`). Stored encrypted by Apify. Required. |
| `mode` | all | `search`, `charity` or `verify`. |
| `queries` | search | Names (at least 3 characters) or US EINs. One request per query. |
| `country` | search | Optional two-letter country code. |
| `maxResultsPerQuery` | search | 1 to 100 (the API returns at most 100 matches per query). |
| `includeDetails` | search, verify | Fetch the full profile per result. One extra request per result. |
| `slugs` | charity | GiveRadar slugs or full profile URLs. |
| `registrations` | verify | Lines like `GB:202918`. |
| `includeFinancials` | all | Add filing history (Pro). One extra request per charity. |
| `includeNews` | all | Add news articles on file. One extra request per charity. |
| `maxRequests` | all | Hard cap on API calls in this run. Default 10. |

**Example: search two names in the UK**

```json
{
    "apiKey": "gr_your_key_here",
    "mode": "search",
    "queries": ["Oxfam", "British Heart Foundation"],
    "country": "GB",
    "maxResultsPerQuery": 5,
    "maxRequests": 10
}
```

**Example: verify registration numbers**

```json
{
    "apiKey": "gr_your_key_here",
    "mode": "verify",
    "registrations": ["GB:202918", "US:131624100"],
    "includeDetails": true,
    "maxRequests": 10
}
```

**Example: full profiles with filing history (Pro key)**

```json
{
    "apiKey": "gr_your_key_here",
    "mode": "charity",
    "slugs": ["oxfam-202918"],
    "includeFinancials": true,
    "maxRequests": 5
}
```

#### Output

One dataset item per charity found. Inputs with no match get an item with `error: "no_match"` (or `not_found` for an unknown slug), so every line of your input is accounted for. Export as JSON, CSV, Excel or through the Apify API.

A verify lookup for `GB:202918` returns:

```json
{
    "query": "GB:202918",
    "country_code": "GB",
    "slug": "oxfam-202918",
    "name": "OXFAM",
    "registration_number": "202918",
    "ein": null,
    "uk_charity_number": "202918",
    "city": "Oxford",
    "state": "England",
    "integrity_score": 81,
    "giveradar_url": "https://giveradar.com/charity/oxfam-202918/",
    "source": "GiveRadar (giveradar.com)",
    "retrieved_at": "2026-10-20T12:00:00.000Z"
}
```

Values change as registries publish new data. Full profiles add fields such as `description`, `website`, `category_group`, `founded_year`, `cause_tags`, `sdg_goals`, `red_flags`, `contact_availability_score`, `data_recency_score` and, on a Pro key, the financial and officer fields. On a Free key, Pro-only fields are `null` and the item carries `data_tier: "free (Pro-only fields are null)"`. The [API documentation](https://giveradar.com/api/docs/) describes every field.

#### What the integrity assessment measures

The integrity score is a 0 to 100 assessment of disclosure and governance signals: Registration (up to 20 points), Financial Transparency (30), Governance (20), Contact Availability (10) and Data Recency (20), with a deduction for active red flags. It measures what a charity discloses, not its impact, and it is not a verdict on whether to donate. The active red flag types are high executive pay, stale filings and bare-minimum disclosure. [How the integrity assessment is calculated](https://giveradar.com/methodology/) explains each component and its limits.

#### Using it with AI agents

You can call this Actor from any agent through the Apify MCP server. If your agent speaks MCP directly, GiveRadar also runs [its own MCP server for charity data](https://giveradar.com/mcp/) with search, compare, find-similar and verify tools, which works with the same API key.

#### Limits worth knowing

- Search matches on the charity name (substring, case-insensitive). Queries shorter than 3 characters return nothing.
- The API returns at most 100 matches per query and has no pagination. This Actor is built for lookups and enrichment, not for downloading whole registers.
- Every attempt counts against your daily quota, including retries after a temporary error. Quotas reset at 00:00 UTC.
- When the quota or `maxRequests` runs out mid-run, the Actor saves what it already fetched and stops cleanly.

#### Data use and attribution

GiveRadar data is compiled from public sources and comes without a guarantee of completeness or accuracy. Under the [GiveRadar terms of service](https://giveradar.com/terms/), commercial and public uses must credit GiveRadar as the source, and raw bulk data may not be resold or redistributed as your own dataset. For bulk or licensing needs beyond the API tiers, contact info@giveradar.com.

#### FAQ

**Do I need a GiveRadar account?**
Yes, to create an API key. The free tier gives 10 requests a day, enough to test the Actor.

**Is my API key safe?**
The key field is marked secret, so Apify stores it encrypted and does not show it in the run input. The Actor only sends it to giveradar.com in the `Authorization` header and never writes it to the dataset or the log.

**Why are revenue and officers empty?**
Those fields need a Pro key. On a Free key they come back as `null`.

**Can I look up a charity by its registration number?**
Yes, with `mode: "verify"`. It accepts EINs (US), Charity Commission numbers (England and Wales), RSIN (Netherlands) and the national registration number for other countries.

**Where do I report a wrong record?**
Email info@giveradar.com. GiveRadar corrects inaccuracies within about 5 business days.

# Actor input Schema

## `apiKey` (type: `string`):

Your own GiveRadar API key (starts with gr\_). Create one at https://giveradar.com/api/. It is stored encrypted by Apify and only sent to giveradar.com. A Free key returns basic fields for 10 requests a day; a Pro key adds financials, officers and contact fields.

## `mode` (type: `string`):

search = find charities by name (or US EIN). charity = fetch full profiles for known GiveRadar slugs. verify = look up a registration number in one country.

## `queries` (type: `array`):

Search mode. Charity names (at least 3 characters) or US EINs such as 13-1624100. One API request per query.

## `country` (type: `string`):

Search mode, optional. Two-letter ISO country code, for example GB, US, NL, CA, AU. Leave empty to search all countries.

## `maxResultsPerQuery` (type: `integer`):

Search mode. The API returns at most 100 matches per query.

## `includeDetails` (type: `boolean`):

Search mode. Adds one extra API request per result (description, registry IDs, website, red flags, integrity components). Watch your quota on a Free key.

## `slugs` (type: `array`):

Charity mode. The slug is the last part of a GiveRadar charity URL, for example oxfam-202918 in giveradar.com/charity/oxfam-202918/. One API request per slug.

## `registrations` (type: `array`):

Verify mode. One per line as COUNTRY:NUMBER, for example GB:202918 or US:131624100. One API request per line.

## `includeFinancials` (type: `boolean`):

Adds up to 10 years of filings per charity from the financials endpoint. One extra request per charity. Requires a Pro or Enterprise key; on a Free key it is skipped after the first refusal.

## `includeNews` (type: `boolean`):

Adds up to 20 news articles on file per charity. One extra request per charity.

## `maxRequests` (type: `integer`):

Hard cap on GiveRadar API calls in this run, so a run can never use more of your daily quota than you intend. Free keys have 10 per day.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "Oxfam"
  ],
  "country": "GB",
  "maxResultsPerQuery": 10,
  "includeDetails": false,
  "includeFinancials": false,
  "includeNews": false,
  "maxRequests": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Charity records returned by the GiveRadar API for this run (search matches, full profiles or verified registrations).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "queries": [
        "Oxfam"
    ],
    "country": "GB"
};

// Run the Actor and wait for it to finish
const run = await client.actor("giveradar/charity-nonprofit-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "queries": ["Oxfam"],
    "country": "GB",
}

# Run the Actor and wait for it to finish
run = client.actor("giveradar/charity-nonprofit-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "queries": [
    "Oxfam"
  ],
  "country": "GB"
}' |
apify call giveradar/charity-nonprofit-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,giveradar/charity-nonprofit-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rPO5fIq8aInA8eP7G/builds/lykUDHA0anEyAgU9x/openapi.json