canonical: https://jentic.com/apis/good-grants/good-grants

# Good Grants API

The Good Grants API exposes 81 endpoints for managing the full lifecycle of a grant or award programme, covering accounts, applications, allocations, categories, chapters, contributors, documents, fields, forms, funds, payments, rounds, seasons, users, and webhooks. It supports regional base URLs (Global, AU, CA, EU, HK, AE, US) so customers can keep data within a specific jurisdiction. Authentication is an x-api-key header, and the resource model maps directly to how grant administrators design rounds, build application forms, score submissions, and disburse funds.

## For AI agents

Manage every part of a grant or awards programme - applications, forms, rounds, scoring, payments, and webhooks - through 81 endpoints across regional Good Grants servers.

## Scope

Does not handle bank disbursement execution, applicant identity verification, or grant-writing content generation - use for grant programme management (applications, forms, rounds, allocations, payments record-keeping, contributors, webhooks) only.

## Capabilities

- Create and update applications submitted to a grant round
- Allocate budget across applications, categories, and rounds
- Build and version application forms with custom fields and chapters
- Manage contributors and reviewers with role-based access to a round
- Record and reconcile payments disbursed to successful applicants
- Subscribe webhooks to react to application, payment, and round events

## Use cases

### External Application Portal

Grant-making organisations build custom-branded portals that submit applications via the Good Grants API while keeping all programme management inside Good Grants. The API's forms and fields endpoints expose the form schema so the portal renders the same questions, and POST /application creates the record under the chosen round.

Example prompt: Render form form_xyz from `/form/{slug}` on a custom portal and POST a completed application against round round_2026.

### Award Disbursement Reconciliation

Finance teams reconcile awarded grants by reading allocations and payments through the API, matching them against bank-side disbursements, and updating fund balances. The /allocation and /payment endpoint groups give a single source of truth for how much of each fund has been committed and paid.

Example prompt: List all payments for season season_2026 and produce a CSV showing applicant, amount allocated, and amount paid.

### Review Committee Workflow

Programme managers add contributors with reviewer roles to a round, assign applications for scoring, and progress applications through stages as scores come in. Webhook subscriptions push status changes back to a Slack channel or CRM so the committee tracks progress without polling.

Example prompt: Add user@example.com as a reviewer on round round_q2 and subscribe a webhook to fire when any application in that round changes status.

### AI Triage Agent via Jentic

An AI agent can read incoming applications, flag missing documents, and assign reviewers based on subject expertise - all by calling the Good Grants API through Jentic. The agent searches for the right operation by intent, loads the schema, and executes against the regional Good Grants base URL with the x-api-key held in the vault.

Example prompt: List applications in round round_q2, fetch each application's documents, and tag any application missing the required budget document.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/application` | List applications |
| POST | `/application` | Create an application |
| GET | `/allocation` | List allocations |
| POST | `/allocation` | Create an allocation |
| POST | `/action-task` | Create an action task |
| GET | `/account` | Get account details |

## Key resources

- **Applications** — Create, read, update, and progress grant applications
- **Allocations** — Track budget allocations across applications, categories, and rounds
- **Forms** — Manage form definitions with chapters and fields
- **Funds** — Manage funds and their balances across awarded applications
- **Payments** — Record and reconcile payments to awarded applicants
- **Rounds** — Configure rounds within a season
- **Seasons** — Group rounds into a programme cycle
- **Contributors** — Manage reviewers and other collaborators on a round
- **Webhooks** — Subscribe to events such as application submission and status change

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 42 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 48 / 100
  - Developer Experience & Jentic Compatibility: 56 / 100
  - AI-Readiness & Agent Experience: 29 / 100
  - Agent Usability: 89 / 100
  - Security: 50 / 100
  - AI Discoverability: 23 / 100
- **View full report:** https://jentic.com/apis/good-grants/good-grants/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Good Grants by hand means implementing its x-api-key header auth and picking the right regional host (api.cr4ce.com or its au, ca, and eu variants) for the account, then mapping the application and allocation endpoints yourself. Through Jentic you install once, import Good Grants from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Good Grants works through top-level resource endpoints like /application and /allocation rather than a resource id in the URL path, so scope the agent to the operations it needs, such as listing applications or reading allocations. You choose the operations it may call, so ones like creating an application or an action-task are not included unless you add them.
- **Credential handling:** Your Good Grants API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list grant applications' or 'read allocations for a round', and Jentic returns the matching Good Grants operation with its query and body schema so the agent calls the right endpoint without browsing the reference.

## Related APIs

- **Submittable** — Submission management platform widely used for grants, awards, and publications.
- **Salesforce REST API** — CRM record-of-truth for applicants and grantees that can sync with Good Grants applications.
- **Stripe** — Pays out approved grants once Good Grants has recorded the allocation.

## FAQ

### What authentication does the Good Grants API use?

The Good Grants API uses an x-api-key header (apiKey scheme) issued per Good Grants account. Through Jentic the key is stored encrypted in the vault and scoped to the matching regional base URL, so the raw key never enters the agent's context.

### Can I create applications programmatically with the Good Grants API?

Yes. POST /application creates an application against a round, and you can attach answers, contributors, and uploaded documents through the related /document and /field endpoints. This lets you build a custom-branded portal that hands off to Good Grants for review and disbursement.

### What are the rate limits for the Good Grants API?

Good Grants applies per-tenant rate limits documented at goodgrants.com/help. The OpenAPI spec does not encode exact numbers, so check the support portal before running bulk imports - list endpoints such as GET /application support pagination and should be used in batches.

### How do I subscribe a webhook through Jentic?

Search Jentic for 'subscribe webhook good grants', load the schema for POST /webhook, and execute with the event type and target URL. Jentic injects the x-api-key at execution and returns the webhook ID, which the agent persists for later management.

### Can I keep my data in a specific region?

Yes. Good Grants exposes regional base URLs - api.cr4ce.com (global), api.au.cr4ce.com, api.ca.cr4ce.com, api.eu.cr4ce.com, api.hk.cr4ce.com, api.ae.cr4ce.com, and api.us.cr4ce.com - and your account is provisioned against one of them. Use the matching server when configuring a client.

### Does the API handle automated scoring of applications?

No. The API records reviewer scores and progresses application status, but the scoring logic itself is configured in the Good Grants UI as part of the round setup. Use the API to read scores and update application status based on them.

### Can I limit what my agent is allowed to do with the Good Grants API?

Yes. Because you self-host Jentic One, your own rules decide which Good Grants operations and credentials the agent may use. The API exposes top-level resource endpoints such as /application and /allocation, so you can grant read-only operations like listing applications or reading allocations while leaving out write operations. Operations such as creating an application or an action-task stay unavailable unless you explicitly add them.
