Usage & Quotas
The Charity Navigator Graph QL API is available through subscription plans. Every plan uses the same
GraphQL endpoint; plans differ by their monthly request quota, the type of data that is available, and the support response time. Usage is
metered as one API request per successful call, against the api_requests
meter shown on your subscription.
Current prices and quotas live on the pricing page. Prices and quotas can change, so this page documents the parts that don't: which queries each plan can call and how usage is counted.
Query access
Queries are grouped into two tags:
- Data Essentials —
publicSearchFacetedandbulkNonprofits. Available on every plan. The deprecatednonprofitsPublicquery is also in this tag and still callable on every plan, but is no longer listed in the GraphQL Explorer — see the changelog. - Premium Data —
publishedAlerts, the paginated feed of published Charity Navigator alerts. Available only on the Midsize and Enterprise plans.
Calling a Premium Data query on a plan without it returns HTTP 403 with a
GraphQL-shaped error body, and does not count against your quota:
Code
The check runs on the whole request, so a single document that selects
publishedAlerts alongside permitted queries is rejected in full. If you are on any other plan and need publishedAlerts, contact us.
How usage is counted
Each successful call counts as one API request against your monthly quota. To keep the count fair, some requests are not counted:
- Cached responses. Repeating an identical query may be served from a cache.
A cached response is not counted against your
quota, so the same query will not move your usage counter again until the entry
expires (up to 24 hours). The cache is keyed to your API key, so your first
call for a given query always reaches the origin and always counts. If you're
watching your usage, vary the query — a different
termor arguments — so each call is a fresh request. - Introspection-only requests. Schema-introspection queries (
__schema,__typename) are never counted. - Failed requests. A request that returns an error — a non-2xx response, or
an HTTP
200whose body contains a GraphQLerrorsarray — is not counted. A query rejected by the access rules above costs you nothing.
Reaching your quota
What happens depends on the kind of plan:
- Fixed-quota plans (Startups, Small, Midsize, Enterprise) stop serving
requests once the monthly quota is used. Further calls receive HTTP
403until the quota resets at the start of the next billing period, including introspection requests. For a higher quota, move to a larger plan from the pricing page. - Academics/Personal Use is usage-based rather than capped. Requests past
the included allowance keep succeeding and are billed as overage at the
per-request rate shown on the pricing page, so a busy month produces a bill
rather than a
403.
Rate limit
Separately from the monthly quota, each API key is limited to 1,000 requests
per minute. Exceeding it returns HTTP 429; the monthly quota returns 403.
The rate limit protects the service against bursts and is not affected by your
plan.
Canceling Your Plan
You can cancel your subscription at any time from the My Subscription section of your developer portal account.
- During your free trial: your access continues through the end of your current trial period — you won't be charged, and you can keep using the API until your trial's original end date.
- After your trial has converted to a paid plan: the same rule applies — your access and API key remain active through the end of your current billing period, and you won't be billed again going forward.
If you change your mind before your access ends, you can reactivate your subscription at any point during that window with no disruption to your integration or data.
Cancel at least 24 hours before your trial's end date to ensure it's processed before your card is charged.
Fair Use
API access is governed by the API Terms of Use. Wherever you display the data, follow the Attribution Guidelines. Every plan carries attribution and data-sharing requirements — see Data Sharing Requirements.