GoFundMe GraphQL API

Getting started

Welcome to our platform! This guide will help you get started with our services.

Step 1: Log in to Partner page

1. Go to the Partner page.
2. Log in with your credentials.
3. If you can't log in or can't find your company, contact GoFundMe support for assistance.

Step 2: Get your Partner code

1. Once you can see your partner dashboard, you should see a referral link at the bottom of the dashboard e.g. https://gofundme.com/partners/create/{code}
2. The last segment of that link is your partnership's unique referral code

Step 3: Create an API key

1. Click on your company button in the top right corner.
2. Select "Account".
3. At the bottom, you have the option to create an API key.
4. Create a new API key and save it somewhere secure, as you will only be able to view it once.

Step 4: Set up your request

1. Open Postman (or your preferred tool for sending POST requests).
2. Set the request type to POST.
3. Use the URL https://graphql.gofundme.com/graphql.
4. Add headers:
   • x-partner-code: Your partner code
   • x-api-key: Your API key
5. Add your GraphQL query as the POST body (see example query below)
6. Send the request

curl --location 'https://graphql.gofundme.com/graphql' \
--header 'x-partner-code: YOUR_PARTNER_CODE' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{"query":"query GetPartnerInfo { partner { code name } }"}'

query GetPartnerInfo {
  partner {
    code
    name
  }
}

If you provided your key correctly, you should get back a response containing your partnership's name and code.

{
  "data": {
    "partner": {
      "code": "GFM",
      "name": "GoFundMe"
    }
  }
}

Next steps

Congratulations! You have successfully completed the getting started guide. Here are some next steps to explore:

• Explore additional GraphQL queries such as https://docs.gofundme.com/#query-fundraiser or https://docs.gofundme.com/#query-charitySearch
• Integrate the API responses into your application.

Query Requirements

All GraphQL queries and mutations sent to the GoFundMe API MUST follow these requirements:

1. Use Named Operations

Every query or mutation must have a name. Anonymous operations are not supported.

Do this (named query):

query GetPartnerInfo {
  partner {
    code
    name
  }
}

Don't do this (anonymous query):

query {
  partner {
    code
    name
  }
}

2. Use Variables Instead of Inline Values

Pass dynamic values as variables rather than embedding them directly in the query string.

Do this (parameterized with variables):

query GetFundraiser($slug: ID!) {
  fundraiser(slug: $slug) {
    title
  }
}

With variables passed separately in the request:

{
  "query": "query GetFundraiser($slug: ID!) { fundraiser(slug: $slug) { title } }",
  "variables": { "slug": "my-fundraiser-slug" }
}

Don't do this (inline values):

query GetFundraiser {
  fundraiser(slug: "my-fundraiser-slug") {
    title
  }
}

Searching for charities

This guide will help you get started with searching for charities supported by GoFundMe or retrieving specific charity details using the nonprofit’s PPGF ID.

How it works

The charitySearch query allows you to retrieve a list of charities that GoFundMe supports based on keywords. This can be used to offer users an option to search for charities to select as a beneficiary for their fundraiser.

The charityByPaypalNonprofitId query allows you to retrieve details of a specific charity using the PPGF ID of that nonprofit. This endpoint is useful for determining which GoFundMe ID a charity has if a pre-selected charity will be the beneficiary of the fundraiser.

Example use cases

charitySearch

Let’s say you want to allow your users to search for any nonprofit to fundraiser for out of the list of available GoFundMe beneficiaries in a particular country. Pass the user’s search term into charitySearch and display the corresponding response back to the user to allow them to select which charity they would like to fundraise for. We encourage using the charity’s npoId (PPGF ID) in the fundraiserCreateDraft mutation.

Search for Red Cross with a country filter GB and return:

• GoFundMe ID
• PPGF ID
• Charity Name
• Charity Country

Query example:

query SearchCharities($searchTerm: String!, $countryCode: CountryCode) {
  charitySearch(searchTerm: $searchTerm, filter: { countryCode: $countryCode }) {
    id
    npoId
    name
    country
  }
}

Variables:

{
  "searchTerm": "red cross",
  "countryCode": "GB"
}

Response:

{
  "data": {
    "charitySearch": [
      {
        "id": "4",
        "npoId": "12345",
        "name": "British Red Cross",
        "country": "GB"
      }
    ]
  }
}

charityByPaypalNonprofitId

Now let’s say you want to enable one (or several) pre-selected charities to the beneficiary. To find the GoFundMe ID for that specific charity, to use as a CharityInput in fundraiserCreateDraft, query charityByPaypalNonprofitId using the corresponding PPGF ID as a parameter.

Search a charity given its PPGF ID and return:

• GoFundMe ID
• Charity Name
• Charity Description

Query example:

query GetCharityByPaypalId($paypalNonprofitId: ID!) {
  charityByPaypalNonprofitId(paypalNonprofitId: $paypalNonprofitId) {
    npoId
    name
  }
}

Variables:

{
  "paypalNonprofitId": 14886
}

Response:

{
  "data": {
    "charityByPaypalNonprofitId": {
      "npoId": "14886",
      "name": "British Red Cross"
    }
  }
}

Connecting to GoFundMe via oAuth

When working with the GoFundMe API your application may need to perform actions directly on behalf of a user. Each user will need to authenticate with GoFundMe to verify their identity and to give your application permission to use and access their data.

OAuth 2.0 is a protocol that allows third-party applications to authenticate with APIs. OAuth 2.0 facilitates two main actions: obtaining an access token through user authorization, and using that access token to make API requests. At the end of a successful OAuth 2.0 exchange, an access token is returned to your application. You will need to submit this token with each API request in order to properly identify your application and access end-user data in a secure manner.

Your application does not need to store or transmit user account names or passwords, but instead relies on application credentials in the form of a Client ID and Client Secret that are unique to your application. The OAuth 2.0 protocol uses these credentials as part of an authorization step in which the user chooses to allow (or deny) your application access their data in GoFundMe. An end user may revoke access granted to your application at any time.

If you are brand new to OAuth 2.0, you can review the official OAuth 2.0 specification. See their Community Resources section for some simplified explanations.

Credentials

There are two credentials that you will need to exercise the OAuth 2.0 Authorization Code Flow: Client ID and Client Secret. You can reach out to GoFundMe to obtain these. Your Client Secret is sensitive and should be stored securely. Never expose your Client Secret in client-facing code e.g. a browser or installed mobile app.

Obtaining Consent

To initiate an OAuth2.0 authorization code flow, you can construct and direct your user to the authorize URL:

https://auth.gofundme.com/oauth2/v1/apps/authorize?response_type=code&client_id={client_id}&redirect_uri={redirect_uri}&scope=openid%20fundraiser:create%20fundraiser:edit&state={state}

Request Parts

• response_type=code: This indicates that you are initiating the Authorization Code Flow (which is the only flow we support)
• client_id: This tells us which client is making the request, and allows us to display your branding on our consent page
• redirect_uri: This is where the user will be automatically redirected upon completing the consent flow
• scope: These are the specific permissions that you are requesting to perform on behalf of a user. For instance, the scope fundraiser:create will let you create a fundraiser directly on behalf of a user
  • openid: includes the OIDC id_token in the token response
  • fundraiser:create: needed for fundraiserCreateDraft
  • fundraiser:edit: needed for fundraiserPublish
  • fundraiser:view: needed for viewer.involvedFundraisers
• state: The state parameter helps to mitigate CSRF attacks, and can also provide you a way to store state that you want to be returned in the redirect. This value should be unique for each new call to /authorize

Token Exchange

Once a user authenticates and completes the consent flow, they will be redirected back to the redirect_uri that was provided to the /authorize request along with an additional code query parameter: {redirect_uri}?code={code}&state={state}

Note: the state value will be identical to what was initially provided to /authorize Using the received code in combination with your Client Secret you can now use the /token endpoint to retrieve an access_token which allows you to act specifically on behalf of the consenting user.

For this request to succeed, you will need to provide your Client ID and Client Secret using the Authorization header in the following base64 encoded format:

Authorization: Basic <Base64(client_id:client_secret)>

For example, with a client_id of 123 and client_secret secret, the expected Authorization header becomes: Authorization: Basic MTIzOnNlY3JldA==

Note: MTIzOnNlY3JldA== is 123:secret base64 encoded.

Additionally, you will need to provide the code in the POST body. A complete example request for the above scenario would look like:

curl --location '<https://auth.gofundme.com/oauth2/v1/apps/token>' \\
--header 'Authorization: Basic MTIzOnNlY3JldA==' \\
--header 'Content-Type: application/x-www-form-urlencoded' \\
--data-urlencode 'grant_type=authorization_code' \\
--data-urlencode 'code=3fa0ed2389a5492e94626606ccb0f9e35deed098cb3dde2abce59f2c508132a6'

The response will follow the format:

{
    "access_token": "{jwt}",
    "token_type": "Bearer",
    "refresh_token": "{jwt}",
    "id_token": "{jwt}",
    "expires_in": 600
}

These tokens are short-lived, and intended to be ephemeral. In the case that a user revokes their consent to your application, your tokens will become invalid.

Using Access Tokens

Once you have obtained an access_token, you will be able to make requests directly on behalf of your user. You will only be able to make requests that fall within what the user consented to during the /authorize step.

To make a request on behalf of a user, you simply need to provide the access_token as an Authorization header following the format: Authorization: Bearer {access_token}

Having done that, you will be able to perform fundraiserCreateDraft (see Creating Fundraisers via API) or other mutations directly on behalf of the user.

A complete example request looks like:

curl --location '<https://graphql.gofundme.com/graphql>' \\
--header 'Authorization: Bearer {access_token}' \\
--header 'Content-Type: application/json' \\
--data-raw '{
  "query": "mutation fundraiserCreateDraft($title: String!) {
    fundraiserCreateDraft(input: {
      title: $title
    }) {
      fundraiser {
        title
      }
    }
  }",
  "variables": {
    "title": "My Fundraiser Title"
  }
}'

Creating and launching fundraisers via API

This guide will help you get started with programmatically creating and publishing fundraisers on GoFundMe.

How it works

The fundraiserCreateDraft mutation allows you to create a draft for a new fundraiser. The partnerPhotoUpload mutation is used in the create process to upload an image and then supply the fundraiserCreateDraft with an image URL.

The fundraiserPublish mutation allows you to publish the created fundraiser. The fundraiser will not be live to the user until it is published.

Example use cases

partnerPhotoUpload

First, upload an image to be used as the cover media for the fundraiser, using the partnerPhotoUpload mutation. Because the request must be multipart/form-data, how your query is structured will vary based on which graphql client you are using. Regardless of which client you use, you must also provide graphql-require-preflight: true on this request because it is multipart.

CURL example:

curl --location 'https://graphql.gofundme.com/graphql' \
--header 'graphql-require-preflight: true' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'x-partner-code: YOUR_PARTNER_CODE' \
--form 'operations={"query":"mutation partnerPhotoUpload($input: Upload!) { partnerPhotoUpload(input: $input) { id url fileSize fileType createdAt}}", "variables":{"input":null}}'
--form 'map={"0": ["variables.input"]}' \
--form '0=@"/path/to/local/file/file.png"'

Response:

{
    "data": {
        "partnerPhotoUpload": {
            "id": "59",
            "url": "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722550606/ca7a4e16-5ac6-4c18-a1be-7bcce969bd08.jpeg",
            "fileSize": 15273,
            "fileType": "image/jpeg",
            "createdAt": "2024-08-01T17:16:47.000-05:00"
        }
    }
}

fundraiserCreateDraft

Then create a draft fundraiser, calling the fundraiserCreateDraft mutation with required inputs. Note: use the URL from the response of partnerPhotoUpload as the mediaUrl.

• country
• category
• expectedBeneficiaryRelation
• charity (if expectedBeneficiaryRelation=CHARITY)
• postalCode
• goalAmount
• title
• description (note: at the moment we do not support full HTML fundraiser descriptions, including emojis)
• mediaUrl

Mutation example (charity fundraiser):

mutation CreateCharityFundraiserDraft($input: FundraiserInput!) {
  fundraiserCreateDraft(input: $input) {
    fundraiser {
      slug
      fundId
      title
    }
    userErrors {
      field
      message
    }
  }
}

Variables:

{
  "input": {
    "title": "A Charity Fundraiser",
    "category": "MEDICAL",
    "charity": {
      "paypalNonprofitId": 14886
    },
    "country": "GB",
    "postalCode": "E1 8RU",
    "goalAmount": 5000,
    "expectedBeneficiaryRelation": "CHARITY",
    "mediaUrl": "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722481246/5a20d214-6685-4348-9789-57fd1b80d0bd.jpeg",
    "partnerAffiliation": {
      "sourceApplication": "Another Application"
    },
    "description": "We are raising money for the British Red Cross. Please show your support by donating and sharing this fundraiser with your community."
  }
}

To create a fund on behalf of the user, use the PartnerExternalOrganizerInput. This indicates that the fundraiser is being created by the partner, on the user's behalf.

FundraiserInput: {
  PartnerExternalOrganizerInput: {
    firstName: "John",
    lastName: "Doe",
    email: "johndoe@gmail.com",
    emailOptIn: true,
    locale: "en-US"
  }
}

Once published, the API will return a FundraiserResponse object. Inside, the FundraiserResponse.Fundraiser.PartnerExternalInput.organizerInviteUrl field contains a unique URL which should be shared with the user so they can officially claim the fundraiser and connect it to their GoFundMe account. For best results, provide the claim link to the user in your UI. GoFundMe will also send this link via email to the user to maximize the claim experience touchpoints.

Important: the fundraiser will not be fully associated to their GoFundMe account until the user completes the claim process, but they can still fundraise as normal.

Mutation example (individual fundraiser):

mutation CreatePersonalFundraiserDraft($input: FundraiserInput!) {
  fundraiserCreateDraft(input: $input) {
    fundraiser {
      slug
      fundId
      title
    }
    userErrors {
      field
      message
    }
  }
}

Variables:

{
  "input": {
    "title": "A Personal Fundraiser",
    "category": "EMERGENCY",
    "country": "GB",
    "postalCode": "E1 8RU",
    "goalAmount": 5000,
    "expectedBeneficiaryRelation": "YOURSELF",
    "mediaUrl": "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722481246/5a20d214-6685-4348-9789-57fd1b80d0bd.jpeg",
    "partnerAffiliation": {
      "sourceApplication": "Another Application"
    },
    "description": "I'm raising money for my school's wildfire relief efforts. Please show your support by donating and sharing this fundraiser with your community."
  }
}

Response:

{
  "data": {
    "fundraiserCreateDraft": {
      "fundraiser": {
        "slug": "e5957e20-5335-4b8c-b1e3-cd8fc8d5d112",
        "fundId": "59024133",
        "title": "A Charity Fundraiser"
      },
      "userErrors": []
    }
  }
}

fundraiserPublish

To publish the draft fundraiser, use the fundraiserPublish mutation with the fundId from fundraiserCreateDraft as the input.

Mutation example:

mutation PublishFundraiser($id: ID!) {
  fundraiserPublish(id: $id) {
    userErrors {
      message
    }
    fundraiser {
      title
      slug
      fundId
    }
  }
}

Variables:

{
  "id": 59024133
}

Response:

{
  "data": {
    "fundraiserPublish": {
      "userErrors": [],
      "fundraiser": {
        "title": "A Charity/ Personal Fundraiser",
        "slug": "a-fundraiser-slug",
        "fundId": "59024133"
      }
    }
  }
}

Additional examples

Automated Goals

Smart Goals is an optional feature that helps high-performing fundraisers raise more by automatically increasing the goal amount once it has been met or surpassed. This gradual adjustment helps maintain momentum and encourages continued donations without the organizer needing to take action.

To enable Smart Goals, use the smartGoalsEnabled field. This feature can be turned off at any time by the fundraiser organizers and by default is off unless explicitly enabled.

FundraiserInput: {
  smartGoalsEnabled: true
}

If Smart Goals are enabled, we recommend showing this copy to the user so they are aware why their goal has changed:

GoFundMe will use data from similar fundraisers to gradually adjust your goal as donations come in, to increase fundraiser success. You can turn this off at any time.

Communications consent

To let GoFundMe contact the organizer with fundraiser best practices, tips, and coaching, include this when creating the fundraiser:

partnerExternalOrganizerInput: {
  emailOptIn: true
}

This allows us to support users directly—improving fundraiser outcomes and increasing the likelihood of success. It’s especially helpful for new organizers who may not know where to start.

Please use the following standard consent language for users to launch their fundraisers:

By clicking on the GoFundMe button above, you agree to have your submitted information used to create a fundraiser on the third-party website or app of our partner GoFundMe, and for GoFundMe to use your information to contact you. You acknowledge that GoFundMe will process your information in accordance with its privacy notice.

If you’re creating a charity-linked fundraiser, and you’d like the nonprofit to receive basic information about the fundraiser creator (such as name and email) so they can provide support or say thank you, include the following.

FundraiserInput: {
  npoMarketingConsent: true
}

This gives the nonprofit visibility into who’s creating fundraisers on their behalf and enables them to deepen relationships with their supporters.

Working with test data

When creating fundraisers for development or testing purposes only, please use the isTestData field.

PartnerAffiliation: {
  isTestData: true
}

This ensures that fundraisers won't appear in GoFundMe search or other public discovery surfaces, that test donations are excluded from core metrics, and a clean separation from production fundraisers.

To further reinforce that these fundraisers are for testing, we recommend including the word "test" or "Test" in the fundraiser title (example: Test Fundraiser for "Partner Name").

Creating Partner fundraisers via referral links

The Partner referral flow is designed to enable partners to refer users to GoFundMe to create fundraisers with minimal development effort on the partner’s end. This is achieved by using specific URL query parameters to pre-fill information where possible, providing a streamlined experience for users and removing steps in the GoFundMe creation user flow.

These fundraisers are attributed to the Partner who refers them through their partnerCode. Attributed fundraisers and donations are accessible in the Partner Dashboard.

How it works

Organizations can refer their users to the Partner flow by appending URL query parameters to their GFM partner link (see partner.gofundme.com for the URL). These query parameters pre-fill specific fields on the fundraiser, reducing the amount of manual input required, and improving the onboarding experience for users.

Below are the supported query parameters.

Parameters able to be passed via referral link

Parameter	Required	Type	Description
zip_code	optional	number	Zip code of the organizer/ fundraiser
country	required	string	Country code of the organizer’s fundraiser (ex: US)
beneficiary_type	optional	string	Beneficiary of the organizer’s fundraiser. Defaults to YOURSELF Options: - YOURSELF - SOMEONE_ELSE
category	optional	string	Category of the fundraiser. See category list
service_date	optional	datetime (UTC) string	Memorial date of the fundraiser. Should only be used with the MEMORIALS category
tp_id	optional	string	A unique external identifier provided by the partner to identify users on GoFundMe’s system. It is used in tandem with other identifiers to ensure a precise mapping of users

Information always collected on GoFundMe (not by the Partner)

Parameter	Description
Goal amount	Target amount to raise
Image	Main image to display on the fundraiser page
Title	Title/ name of the fundraiser
Story	Description of the fundraiser

Examples

Create a Fundraiser with no query params
If no query parameters are passed along with the Partner referral link then the user will be redirected to gofundme.com/create and go through the regular GoFundMe creation process.

https://www.gofundme.com/partners/create/{partnerCode}

Create a Fundraiser with just country as a param
This is the minimum viable set of query parameters to create a draft fundraiser using the streamlined Partner flow. This query uses the required country parameter.

https://www.gofundme.com/partners/create/{partnerCode}?country=US

Create a Fundraiser with country, zip_code, category, beneficiary_type as params

https://www.gofundme.com/partners/create/{partnerCode}?country=US&zip_code=92618&category=Animals&beneficiary_type=YOURSELF

Create a Fundraiser with category, category, service_date, & tp_id as params

https://www.gofundme.com/partners/create/{partnerCode}?country=US&category=Memorials&service_date=2025-01-03T10%3A15%3A30Z&tp_id=01234

Retrieving donations/ fundraisers

This guide will help you get started with querying data to retrieve all the fundraisers or donations associated with fundraisers that were published via your GoFundMe partner account.

How it works

The partner.fundraiser query allows you to retrieve all fundraisers associated with your partner account. The fundraiser.donations query allows you to retrieve all donations to a given fundraiser. The partner.donations query allows you to retrieve all donations to all fundraisers associated with your partner account.

Example use cases

partner.fundraisers

To query all fundraisers associated with your partner account partner.fundraisers.

Query example:

query GetPartnerFundraisers {
  partner {
    fundraisers {
      edges {
        node {
          title
          description
        }
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "fundraisers": {
        "edges": [
          {
            "node": {
              "title": "Partner Fundraiser 1",
              "description": "A fundraiser description for a test campaign"
            }
          },
          {
            "node": {
              "title": "Partner Fundraiser 2",
              "description": "Another description for a test campaign"
            }
          }
        ]
      }
    }
  }
} 

fundraiser.donations

To query all donations to one particular fundraiser, use fundraiser.donations. Use pagination and hasNextPage to determine when you’ve reached the end of a connection.

Query example:

query GetFundraiserDonations($slug: ID!) {
  fundraiser(slug: $slug) {
    donations {
      pageInfo {
        hasNextPage
        hasPreviousPage
        startCursor
      }
      edges {
        cursor
        node {
          name
          amount {
            currencyCode
            amount
          }
          createdAt
        }
      }
    }
  }
}

Variables:

{
  "slug": "example-campaign"
}

Response:

{
  "data": {
    "fundraiser": {
      "donations": {
        "pageInfo": {
          "hasNextPage": true,
          "hasPreviousPage": false,
          "startCursor": "RG9uYXRpb246aWQ6NzYyODM4OTI1"
        },
        "edges": [
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODM4OTI1",
            "node": {
              "name": "Test Donor",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-17T12:40:33.000-05:00"
            }
          },
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODg4ODk1",
            "node": {
              "name": "John Doh",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-27T16:32:20.000-05:00"
            }
          },
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODkyODY1",
            "node": {
              "name": "Another Donor",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-28T13:42:06.000-05:00"
            }
          }
        ]
      }
    }
  }

partner.donations

To query all donations associated with your partner account partner.donations. Use pagination and hasNextPage to determine when you’ve reached the end of a connection.

Query example:

query GetPartnerDonations {
  partner {
    donations {
      pageInfo {
        hasNextPage
        hasPreviousPage
        startCursor
      }
      edges {
        node {
          name
          amount {
            currencyCode
            amount
          }
          fundraiser {
            title
            fundId
          }
        }
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "donations": {
        "pageInfo": {
          "hasNextPage": true,
          "hasPreviousPage": false,
          "startCursor": "RG9uYXRpb246aWQ6NzYxNTg1NjIz"
        },
        "edges": [
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Product Testing",
              "amount": {
                "currencyCode": "USD",
                "amount": 7
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Ksenia Cat",
              "amount": {
                "currencyCode": "USD",
                "amount": 7
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          }
        ]
      }
    }
  }
}

Retrieving a user's fundraisers via OAuth

This guide will help you get started with querying data to retrieve all the fundraisers organized by a user that has consented to share this information with your partner account.

How it works

The viewer.involvedFundraisers query allows you to retrieve fundraisers for the user associated with the OAuth access token you provide. This query will not return data if the access token does not include the fundraiser:view scope.

Example use cases

viewer.involvedFundraisers

Query example:

query GetViewerFundraisers($filter: FundraiserFilter, $first: Int, $order: FundraiserOrder) {
  viewer {
    involvedFundraisers(filter: $filter, first: $first, order: $order) {
      edges {
        node {
          fundId
          title
          description
        }
      }
    }
  }
}

Variables:

{
  "filter": {
    "myRelationships": ["ORGANIZER"],
    "isPublished": true
  },
  "first": 50,
  "order": "CREATED_AT"
}

Response:

{
  "data": {
    "viewer": {
      "involvedFundraisers": {
        "edges": [
          {
            "node": {
              "fundId": "12345",
              "title": "Test fundraiser 1",
              "description": "test fundraiser description 1"
            }
          },
          {
            "node": {
              "fundId": "123456",
              "title": "Test fundraiser 2",
              "description": "test fundraiser description 2"
            }
          },
          {
            "node": {
              "fundId": "123457",
              "title": "Test fundraiser 3",
              "description": "test fundraiser description 3"
            }
          }
        ]
      }
    }
  }
}

Creating and managing campaigns

This guide will help you get started with creating and managing campaigns on GoFundMe. Campaigns allow nonprofits and partners to organize coordinated fundraising events where multiple supporters create individual fundraisers under a shared banner.

We'll walk through the full lifecycle of a campaign using a running challenge as our example: "100 Miles in January" — a campaign where participants commit to running 100 miles during the month of January to raise money for a charity.

How it works

A Campaign represents a fundraising event that groups together multiple fundraisers under a common goal. Partners can create campaigns via the campaignCreate mutation, access their campaigns via the partner.campaigns query, and associate individual fundraisers with a campaign at creation time using partnerFundraiserInput.campaignRegistration.

Optionally, you can add a fitness challenge to any campaign after it has been created by using the campaignConfigurationUpdate mutation. This enables activity tracking (e.g., run 100 miles) for all fundraisers created under the campaign.

Creating a campaign

Use the campaignCreate mutation to create a new campaign. You must provide the campaign details and a list of charity IDs that the campaign supports.

In this example, we create the "100 Miles in January" campaign, set a $25,000 overall fundraising goal, and configure default values that will be pre-filled for participants when they create their own fundraisers.

Mutation example:

mutation {
  campaignCreate(
    input: {
      name: "100 Miles in January"
      description: "Kick off the new year by committing to run 100 miles in January. Every mile you run raises money for children's health programs."
      goal: 25000.00
      imageUrl: "https://www.gofundme.com/campaignassets/100-miles-january.jpeg"
      startDate: "2026-01-01T00:00:00Z"
      endDate: "2026-01-31T23:59:59Z"
      defaultFundraiserTitle: "My 100 Miles in January"
      defaultFundraiserDesc: "I'm running 100 miles this January to support children's health programs. Every donation keeps me going — please support my challenge!"
      defaultFundraiserImageUrl: "https://www.gofundme.com/campaignassets/100-miles-default.jpeg"
      defaultFundraiserGoal: 250
      fundraiserSmartGoal: true
      enableLeaderboards: true
      challengeTimeframe: true
      challengeStartDate: "2026-01-01T00:00:00Z"
      challengeEndDate: "2026-01-31T23:59:59Z"
      selectedCategoryOptions: [
        { optionId: "10", optionType: DEFAULT }
        { optionId: "11", optionType: DEFAULT }
      ]
    }
    charityIds: ["14886"]
  ) {
    campaign {
      id
      name
      description
      goal
      startDate
      endDate
    }
    userErrors {
      field
      message
    }
  }
}

Response:

{
  "data": {
    "campaignCreate": {
      "campaign": {
        "id": "456",
        "name": "100 Miles in January",
        "description": "Kick off the new year by committing to run 100 miles in January. Every mile you run raises money for children's health programs.",
        "goal": 25000.00,
        "startDate": "2026-01-01",
        "endDate": "2026-01-31"
      },
      "userErrors": []
    }
  }
}

The CampaignCreateInput supports the following fields:

Field	Required	Description
name	Yes	The name of the campaign
description	No	A description of the campaign
goal	No	The overall fundraising goal for the campaign
imageUrl	No	URL of the campaign's cover image
startDate	No	The start date of the campaign
endDate	No	The end date of the campaign
defaultFundraiserTitle	No	Default title pre-filled for fundraisers created under this campaign
defaultFundraiserDesc	No	Default description pre-filled for fundraisers created under this campaign
defaultFundraiserImageUrl	No	Default cover image for fundraisers created under this campaign
defaultFundraiserGoal	No	Default goal amount for fundraisers created under this campaign
fundraiserSmartGoal	No	Whether to enable Smart Goals for campaign fundraisers
enableLeaderboards	No	Whether to enable leaderboards for the campaign
challengeTimeframe	No	(If challenge) Whether the challenge is time-bounded
challengeStartDate	No	(If challenge) Start date of the challenge period
challengeEndDate	No	(If challenge) End date of the challenge period
selectedCategoryOptions	No	(If challenge) List of activity types available to participants. Each entry requires an optionId and an optionType (e.g., DEFAULT). Example: [{ optionId: "10", optionType: DEFAULT }]

Adding a challenge to the campaign

Campaign configuration must be done after the campaign has been created. To add a fitness challenge, use the campaignConfigurationUpdate mutation with the campaign ID returned from campaignCreate. Set the challenge goal and unit inside the challenge input.

For the "100 Miles in January" campaign, we configure a 100-mile running challenge that participants will track progress against:

Mutation example:

mutation {
  campaignConfigurationUpdate(
    id: "456"
    input: {
      challenge: {
        goal: 100
        unit: miles
      }
    }
  ) {
    configuration {
      challenge {
        goal
        unit
      }
    }
    userErrors {
      field
      message
    }
  }
}

Response:

{
  "data": {
    "campaignConfigurationUpdate": {
      "configuration": {
        "challenge": {
          "goal": 100,
          "unit": "miles"
        }
      },
      "userErrors": []
    }
  }
}

The CampaignChallengeConfiguration defines the following fields:

Field	Description
goal	The numeric target for the challenge (e.g., 100 for 100 miles)
unit	The unit of measurement. One of: miles, kilometers, steps, hours, minutes, days, laps, reps, floors, times

When a campaign has a challenge configured, fundraisers created under that campaign can track their progress via fitnessActivityTrackingSettings on the fundraiser. If the campaign has challengeTimeframe set to true, the challenge is time-bounded by challengeStartDate and challengeEndDate.

Challenge category options

When a campaign has a challenge, you can specify which activity types are available to participants via selectedCategoryOptions on campaignCreate or campaignUpdate. These control which fitness activities participants can choose when creating a fundraiser under the challenge.

To discover the available category options and their IDs, use the campaignCategoryOptions query:

Query example:

query {
  campaignCategoryOptions(filter: { type: DEFAULT }) {
    id
    name
    categoryId
    categoryName
    type
  }
}

Response:

{
  "data": {
    "campaignCategoryOptions": [
      {
        "id": "10",
        "name": "Run",
        "categoryId": "1",
        "categoryName": "Running",
        "type": "DEFAULT"
      },
      {
        "id": "11",
        "name": "TrailRun",
        "categoryId": "1",
        "categoryName": "Running",
        "type": "DEFAULT"
      }
    ]
  }
}

Use the id values from this response as the optionId when setting selectedCategoryOptions on campaignCreate.

Once a campaign has category options configured, you can also query them via categoryOptions on the campaign itself, which returns a list of CampaignCategoryMapping objects.

The following activity types are available as category options:

Activity Type	Activity Type	Activity Type
Crossfit	Run	VirtualRide
Hike	Swim	VirtualRun
Pickleball	TrailRun	Walk
Ride	WeightTraining	Yoga

For the "100 Miles in January" campaign, the category options might look like this:

Query example:

query {
  partner {
    campaigns {
      id
      name
      categoryOptions {
        categoryId
        categoryName
        categoryOptionId
        categoryOptionName
        categoryOptionDisplayName
        categoryOptionDescription
        trackingUnits
        selected
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "campaigns": [
        {
          "id": "456",
          "name": "100 Miles in January",
          "categoryOptions": [
            {
              "categoryId": "1",
              "categoryName": "Running",
              "categoryOptionId": "10",
              "categoryOptionName": "Run",
              "categoryOptionDisplayName": "Running",
              "categoryOptionDescription": "Track your running miles toward the 100-mile goal",
              "trackingUnits": ["miles", "kilometers"],
              "selected": true
            },
            {
              "categoryId": "1",
              "categoryName": "Running",
              "categoryOptionId": "11",
              "categoryOptionName": "TrailRun",
              "categoryOptionDisplayName": "Trail Running",
              "categoryOptionDescription": "Hit the trails and log your miles toward the 100-mile goal",
              "trackingUnits": ["miles", "kilometers"],
              "selected": true
            }
          ]
        }
      ]
    }
  }
}

Updating a campaign

Use the campaignUpdate mutation to update an existing campaign. All fields in the input are optional — only the fields you provide will be updated.

For example, if the "100 Miles in January" campaign is gaining traction and you want to raise the overall fundraising goal:

Mutation example:

mutation {
  campaignUpdate(
    id: "456"
    input: {
      goal: 50000.00
      description: "Kick off the new year by committing to run 100 miles in January. We've doubled our goal — every mile you run raises money for children's health programs."
    }
  ) {
    campaign {
      id
      name
      goal
      description
    }
    userErrors {
      field
      message
    }
  }
}

Response:

{
  "data": {
    "campaignUpdate": {
      "campaign": {
        "id": "456",
        "name": "100 Miles in January",
        "goal": 50000.00,
        "description": "Kick off the new year by committing to run 100 miles in January. We've doubled our goal — every mile you run raises money for children's health programs."
      },
      "userErrors": []
    }
  }
}

Querying campaigns

partner.campaigns

To retrieve all campaigns associated with your partner account, use partner.campaigns.

Query example:

query {
  partner {
    campaigns {
      id
      name
      description
      goal
      startDate
      endDate
      imageUrl
      configuration {
        challenge {
          goal
          unit
        }
      }
      metrics {
        totalDonors
        totalFundraisers
        totalRaised
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "campaigns": [
        {
          "id": "456",
          "name": "100 Miles in January",
          "description": "Kick off the new year by committing to run 100 miles in January. Every mile you run raises money for children's health programs.",
          "goal": 25000.00,
          "startDate": "2026-01-01",
          "endDate": "2026-01-31",
          "imageUrl": "https://www.gofundme.com/campaignassets/100-miles-january.jpeg",
          "configuration": {
            "challenge": {
              "goal": 100,
              "unit": "miles"
            }
          },
          "metrics": {
            "totalDonors": 210,
            "totalFundraisers": 45,
            "totalRaised": 11250.00
          }
        }
      ]
    }
  }
}

fundraiser.campaign

To check which campaign a fundraiser belongs to, query the campaign field on a fundraiser.

Query example:

query {
  fundraiser(slug: "sarahs-january-miles") {
    title
    campaign {
      id
      name
      goal
      configuration {
        challenge {
          goal
          unit
        }
      }
      metrics {
        totalRaised
        totalFundraisers
      }
    }
  }
}

Response:

{
  "data": {
    "fundraiser": {
      "title": "Sarah's 100 Miles in January",
      "campaign": {
        "id": "456",
        "name": "100 Miles in January",
        "goal": 25000.00,
        "configuration": {
          "challenge": {
            "goal": 100,
            "unit": "miles"
          }
        },
        "metrics": {
          "totalRaised": 11250.00,
          "totalFundraisers": 45
        }
      }
    }
  }
}

Campaign metrics

Use CampaignMetrics to track the overall performance of a campaign. This is available on the metrics field of a Campaign.

Field	Description
totalDonors	Total number of unique donors across all campaign fundraisers
totalFundraisers	Total number of fundraisers created under the campaign
totalRaised	Total amount raised across all campaign fundraisers

Creating a fundraiser for a campaign

To create a fundraiser that is part of the "100 Miles in January" campaign, use partnerFundraiserInput.campaignRegistration in fundraiserCreateDraft. This associates the new fundraiser with the campaign and registers the participant at the same time.

After creating the draft, use the fundraiserPublish mutation to make the fundraiser publicly visible. See Creating Fundraisers via API for details on publishing.

Mutation example:

mutation {
  fundraiserCreateDraft(input: {
    title: "Sarah's 100 Miles in January"
    category: CHARITY
    charity: {
      paypalNonprofitId: 14886
    }
    country: "US"
    postalCode: "92618"
    goalAmount: 250
    expectedBeneficiaryRelation: CHARITY
    mediaUrl: "https://www.gofundme.com/partnerassets/partner-uploads/sarah-running.jpeg"
    description: "I'm taking on the 100 Miles in January challenge! I'll be running every day this month to raise money for children's health programs. Please support my miles!"
    partnerFundraiserInput: {
      campaignRegistration: {
        campaignId: "456"
        firstName: "Sarah"
        lastName: "Johnson"
        email: "sarah.johnson@example.com"
        locale: "en-US"
      }
    }
    partnerAffiliation: {
      sourceApplication: "Partner App"
    }
  }) {
    fundraiser {
      slug
      fundId
      title
      campaign {
        id
        name
      }
    }
    userErrors {
      field
      message
    }
  }
}

Response:

{
  "data": {
    "fundraiserCreateDraft": {
      "fundraiser": {
        "slug": "sarahs-january-miles",
        "fundId": "59024200",
        "title": "Sarah's 100 Miles in January",
        "campaign": {
          "id": "456",
          "name": "100 Miles in January"
        }
      },
      "userErrors": []
    }
  }
}