calendar_calendars
ChatGPTList the calendars configured in Planning Center Calendar (e.g. "Youth Ministry", "Staff", "Worship"). Calendars partition an organization's events by ministry or context. Use this tool to see which calendars exist, resolve a calendar name to its id, or look up a calendar's description, color, or default status. This tool returns the full list of calendars; there is no server-side filtering by name or any other attribute. Organizations have only a small handful of calendars, so retrieve them all and match the one you want by name client-side.
calendar_conflicts
ChatGPTRead booking conflicts in Planning Center Calendar — situations where two events have overlapping resource requests for the same room or piece of equipment. A conflict carries the contested resource, the winner event once staff have picked one, and resolved_at when the conflict has been settled. Use filter: ["unresolved"] to answer "what's overbooked right now" — that's the operationally interesting set, and it inherently scopes to conflicts on upcoming events (past-only conflicts drop out). filter: ["resolved"] returns conflicts that have been settled. The resource relationship id chains to the calendar_resources tool; the winner event id chains to calendar_events. Both are surfaced as JSON:API relationship linkages on every response.
calendar_event_instances
ChatGPTSearch specific occurrences of events in Planning Center Calendar — the "what is happening at this date and time" surface. An event instance is one occurrence of a parent event: a single Wednesday of a weekly Bible Study, next Sunday's service, or the one date of a one-off event. Recurring instances expose recurrence and compact_recurrence_description for human-readable patterns. Prefer this tool over calendar_events when the question is about specific dates or times ("what's happening next Sunday?", "when does the youth retreat happen?", "the next four Wednesdays of Bible Study"). Use calendar_events instead when the question is about the parent event template regardless of when it occurs. For questions about one particular event, resolve it with calendar_events and pass its id as event_id — more reliable than an event_name substring match when several events share a word. Pair it with filter: ["future"] for "when does this happen next?". Use filter: ["future"] for upcoming instances without computing a date filter yourself. Filter by name via event_name (a phrase-substring match — pass a bare substring like "bible study"; wildcards are not supported), by kind, by date range, by tag, or by calendar. To filter by tag, call calendar_tags to resolve a tag name to a tag id, then pass tag_ids here to narrow to that ministry, audience, or category. To filter by calendar, call calendar_calendars to resolve a calendar name to a calendar id, then pass calendar_ids here. description, image_url, and kind are heavier fields (rich HTML, image URL, event kind) and are only returned when you list them explicitly in output_fields.
calendar_events
ChatGPTSearch events in Planning Center Calendar. Calendar is the organization-wide event discovery surface and absorbs events originating in Groups and Registrations — a small group meeting and an event signup both appear here alongside Calendar-native events, which can themselves be linked to a Services service type. Use this tool to find events across products: by name, approval status, Church Center visibility, feed, created/updated date, or the future named scope for upcoming events. Two views of the same record are simultaneously true: an event surfaced here may also be the source-of-truth for a product-native tool. When the user wants product-specific detail — a Services plan's order of service, a Registrations signup's attendees, a Group's roster — chain into services_plans, registrations_signups, or groups_events after discovering the event here. This tool doesn't surface which calendar an event belongs to — no calendar field or include here. To work by calendar, resolve the calendar id with calendar_calendars and pass it to calendar_event_instances as calendar_ids. That returns one row per occurrence, so dedupe on the event relationship id to count events.
calendar_feeds
ChatGPTList the feeds configured in Planning Center Calendar. A feed is the pipe that carries events into Calendar from somewhere else: an organization has one Registrations feed, one Groups feed per group type, and one feed per Calendar form. Use this tool to resolve a feed's name or kind to the id that calendar_events accepts as feed_id. There is no server-side filtering by name, so filter by feed_type and match any name yourself. Events created directly in Calendar belong to a built-in feed whose id is the literal string "calendar", so pass that to feed_id rather than looking it up. Setting feed_type returns every match in one unordered response, so order_by, per_page, and page_after apply only to an unfiltered list.
calendar_resource_bookings
ChatGPTSearch resource bookings in Planning Center Calendar — a successful reservation of a room or piece of equipment for an event, over a start/end time range. Use this tool to answer "what's booked?" questions, e.g. whether a room is reserved during a time window, or what's reserved for a particular event or occurrence. Provide resource_id (resolved via calendar_resources) to scope to a single room or resource, event_id (resolved via calendar_events) to scope to a single event's bookings, or event_instance_id (resolved via calendar_event_instances) to scope to one specific occurrence — provide at most one of the three. Omit all three to search bookings across the whole organization. Recurring events (weekly services, ongoing classes) attach their bookings to the individual event instance rather than the parent event, so prefer event_instance_id for "what's booked for this Sunday/this occurrence?" questions. Use the event_resource_request include to identify what was reserved and its approval status; chain into calendar_events for richer event detail — this tool does not include the full event record. A booking is a successful reservation, distinct from a scheduling conflict (overlapping reservations awaiting staff resolution) — for "what's overbooked?" questions, use calendar_conflicts instead.
calendar_resources
ChatGPTSearch rooms and equipment available for booking in Planning Center Calendar. A "resource" is either a physical space (kind='Room') or an item of equipment (kind='Resource'). Each resource carries a path_name in the output showing its folder location (e.g. "Main Campus/Sanctuary"); path-based filtering isn't supported server-side, but you can scope to a specific folder via resource_folder_id (chain from include: resource_folder). Use this tool when the question is about space or equipment booking — "what rooms can we book?", "list all our A/V equipment", "which resources do we have?". If instead the question is about check-in setup (where kids get dropped off, which station a family checks in at), that's a Check-Ins locations concept and belongs to a separate Check-Ins tool. Resource ids returned here chain forward to Calendar tools that answer "is this resource booked at time X."
calendar_tags
ChatGPTRead tags used to organize events in Planning Center Calendar. Tags are the vocabulary an organization uses to categorize events by ministry, audience, or context (e.g. "Youth Ministry", "All-Church"). Use this tool to resolve a tag name to a tag id, browse the available tags, or find tags within a specific tag group. Tag ids chain forward to calendar_event_instances via its tag_ids filter for server-side filtering of event instances by tag. Server-side filtering of calendar_events by tag id is not supported; use the tags include on calendar_events if you need tag data alongside events. Include tag_group to see how tags are grouped (e.g. "Audience", "Ministry"); the "Individual Tags" bucket in the UI corresponds to tags with no tag group and can be filtered via filter: "individual". To list the tag groups themselves, call this tool with include: ["tag_group"] and dedupe the tag_group relationships client-side.
check_ins_check_ins
ChatGPTSearch individual check-in records — one row per person per event session, showing who checked in to which event, when, where, and whether they were checked out. Use for attendance questions where individual identity matters (e.g. "who checked in to the 9am service last Sunday", "did the Smith family check in this morning"). Each record covers regular attendees, guests, or volunteers; filter by event, person, date, or check-in category. checked_out_at is ambiguous when null: it can mean the person hasn't been picked up yet, OR that the org doesn't record check-outs at all (many don't — they only badge people in). Report what the data shows and surface the ambiguity rather than asserting someone wasn't picked up. Use include=checked_out_by to surface the picker-upper when it was recorded. security_code, medical_notes, emergency_contact_name, and emergency_contact_phone_number are stripped from every response before it reaches you — the upstream API exposes them to admins, but this tool removes them on both the primary check-in record and any included resources. Sibling tools to disambiguate: - check_ins_check_ins (this tool) — one row per person per event session. Use for "who" and "how many" when individual identity matters. - check_ins_headcounts — pre-aggregated totals by event/category. Use for "how many" when only the count matters and no PII is needed (and the org actually recorded headcounts). - services_plans — planning-side schedules (who's scheduled to play / on the rotation), NOT attendance. To find check-ins for a Registrations signup, follow the chain: registrations_signups returns a signup id → pass that as registration_event_id on check_ins_events → take the resulting Check-Ins event's id → pass it as event_id here. The reverse direction (a Check-Ins event back to its source signup) is not exposed.
check_ins_event_times
ChatGPTList the individual sessions (event times) configured within a Check-Ins event — e.g. the 9:00 and 11:00 services of a Sunday Service event, or each night of VBS. Returns start times, when the session is visible in check-in UIs (shows_at/hides_at), and per-session attendance counts (regular_count, guest_count, volunteer_count). Pass event_id from check_ins_events to drill into a specific event's sessions. Only the current period's sessions are returned when scoped this way — historical sessions from past occurrences of a recurring event aren't available on this route. Omit event_id for an organization-wide list.
check_ins_events
ChatGPTSearch events configured in Check-Ins (e.g. Sunday Service, Wednesday VBS). Returns events that are set up for check-in — not Calendar events, Services plans, or Registrations signups. Events may be native to Check-Ins or auto-created from a Registrations signup. To find the Check-Ins event spawned by a specific signup, pass the signup's event id as registration_event_id. (Going the other direction — a Check-Ins event back to its source signup — is not exposed on this endpoint.)
check_ins_headcounts
ChatGPTSearch manually-recorded headcount tallies for Check-Ins event times — counts that staff explicitly entered in the Headcounts app (e.g. "9am service / Adults = 187"). Each row pairs one event_time with one attendance_type and a total. An absent row may mean the count was zero. Use this only for explicit-tally counts. For attendance derived from individual people scanning in at a station, use check_ins_check_ins and aggregate. For who is scheduled on a service team for that service time, use services_plans instead. Pass event_time_id (an id from check_ins_event_times) to scope tallies to one session — the direct way to read or compare specific sessions (9am vs 11am). Headcount itself is only queryable by created_at / updated_at, so a time-window prompt ("last Sunday's 9am service") still means finding the session in check_ins_event_times first (by its starts_at) and passing its event_time_id here. Attendance-type names come from the included attendance_type resource (included by default); there is no separate MCP tool that lists attendance types, so this include is the only source of attendance-type names.
check_ins_locations
ChatGPTSearch check-in locations configured for a single Check-Ins event — rooms, age groups, and other places people check in to. Each location has age, grade, and gender gating that determines who's allowed to check in there. Requires an event_id; look one up with check_ins_events. Some locations have kind="Folder", meaning they don't accept check-ins themselves — they contain other locations. Use include=locations to descend into a folder's children and include=parent to walk back up. To drop folders and return only check-in-able locations, pass filter="locations"; to keep only top-level entries (no parent folder), pass filter="root". Note: Check-Ins locations are distinct from Calendar resources (physically bookable spaces like the sanctuary) — if a prompt says "rooms," confirm which is meant.
church_campuses
ChatGPTSearch for church campuses in the currently logged in user's organization.
giving_batch_groups
ChatGPTList giving batch groups — optional, customizable collections of giving batches that share common characteristics. Each group carries total_cents/total_currency totals and a committed/status state (uncommitted, updating, or committed), and committing a group commits all of its batches and donations. Limit to committed or in_progress (uncommitted) groups, find a group by a partial match on its description, narrow by updated_at range, include the owner (the Giving admin who created it), and sort by updated_at. Use giving_batches to drill into the individual batches within a group.
giving_batches
ChatGPTList giving batches — groupings of donations. A batch starts uncommitted (status in_progress), acting as a staging area where its donations aren't yet visible to donors, and becomes visible once committed (status committed, with a committed_at timestamp). Each batch carries total_cents/total_currency totals (and donations_count on request). Filter to committed or in_progress batches, narrow by updated_at or committed_at range, and include the batch_group it belongs to or its owner (the Giving admin who created it). Sort by committed_at to surface the most recently committed batches.
giving_donations
ChatGPTSearch donations in Planning Center Giving - the individual gifts a church has received, with the amount, how it was paid, when it arrived, and whether it was refunded. All money is in cents (amount_cents 5000 is $50.00). received_at is the business date a gift counts toward and what the Giving admin UI filters on - prefer it over created_at, which is when the record was entered. Searches the whole organization by default. Pass at most one of person_id (one donor's giving history), batch_id (the gifts in one batch), or campus_id - none of these is filterable org-wide, so scoping to one changes which endpoint is used. A donation carries a single total with no fund attribution of its own: include designations.fund to see which funds a gift was split across, or filter by fund_id to answer "how much came into one fund". For totals, set include_totals - the response meta then carries received_total_amount_cents across everything matching the filters, ignoring pagination. Use it rather than paging through results to sum them by hand.
giving_donors
ChatGPTPer-donor giving totals in Planning Center Giving. Each row is one person who gave inside a date range, with their total, how many donations it came from, and when they first ever gave. Set received_at_start and received_at_end to the window you mean. The applied window isn't echoed back, so name the range you used. There is no combined household row. Each person in a couple is their own row with their own total, so a couple's combined giving means fetching both and adding total_received_donation_amount_cents yourself. Read total_received_donation_amount_cents with total_received_donation_amount_currency; it is in that currency's minor units. donation_count includes refunded and failed donations while the total counts only what was received, so the two don't divide into an average gift. first_donated is the lifetime first gift, not the first inside the range, and can be null even for someone with donations — a missing value doesn't mean they never gave. Rows carry no links.html, so don't promise a donor a page or construct a URL for one. For what someone committed to give rather than what they gave, use giving_pledges.
giving_funds
ChatGPTList the giving funds configured for the organization. Funds track the intent of a donation (e.g. "General", "Building", "Missions") and let donors allocate gifts to a specific cause. Use default: true to find the organization's default fund.
giving_payment_sources
ChatGPTList the payment sources configured for the organization. A payment source is the platform a donation originated from — donations made through Giving carry the built-in "Planning Center" source, while donations imported from an external platform (Stripe, Pushpay, Tithe.ly, etc.) carry a source identifying that platform. This is organization-level configuration only and returns no donor or donation data. status is either active or archived. Archived sources can't be assigned to new donations, but their historical donations are retained. One exception: the built-in "Planning Center" source returns status as the number 0 (meaning active) and returns no created_at/updated_at — treat it as always-active and always-present rather than filtering on those fields. payment_source_type is only returned by organizations that have that feature enabled, so it may be absent from results. In practice organizations have a handful of sources. The endpoint offers no filters or sorting, so narrow the results yourself after fetching. giving_donations can't filter by payment source, but each donation carries its payment_source relationship — to split totals by source, group the donations by that id and match it against the sources here.
giving_pledge_campaigns
ChatGPTList pledge campaigns in Planning Center Giving — long-term commitment drives toward a goal (a building campaign, a missions push). Each campaign carries its goal_cents target and two running totals: received_total_from_pledges_cents (gifts that closed against a pledge) and received_total_outside_of_pledges_cents (gifts to the same fund with no pledge behind them). Reach for this for campaign-level progress questions like "how are we tracking against the building campaign goal?" Each campaign belongs to a fund. Filter by fund_id to find every campaign supporting a specific fund (look the fund up with giving_funds first), or include fund to see its name alongside each campaign. This tool returns campaign-level aggregates only — for the individual pledges behind a campaign, use giving_pledges. There is no "active" filter, so compose one from the date bounds — and set both together, not just one. A campaign is active when it has started and has not yet ended, so send starts_at_end = today (started on or before today) and ends_at_start = today (ends on or after today) in the same call. Sending only one bound returns campaigns that may already be over or not yet started, not active ones. To surface the campaigns wrapping up soonest, sort by ends_at ascending with no date bounds — that is a separate question from "active", so don't add the date filters unless the user asked only for active campaigns.
giving_pledges
ChatGPTLook up pledges in Planning Center Giving - a person's commitment to give a set amount toward a pledge campaign, alongside how much they have actually donated against that commitment so far. Provide exactly one of person_id (the pledges one person has made) or pledge_campaign_id (everyone who pledged to one campaign). Each pledge carries amount_cents (the amount committed) and donated_total_cents (the amount delivered so far). To find donors who are behind on their commitments, compare those two fields on the returned records - there is no server-side filter for it, so the arithmetic has to be done here. When the pledger belongs to a joint giving unit - the "and Jane" half of "John and Jane pledged $5,000" - joint_giver_amount_cents and joint_giver_donated_total_cents carry that second person's amounts; both are 0 otherwise. Include joint_giver to see who they are.
giving_recurring_donations
ChatGPTLook up recurring donations in Planning Center Giving - a donor's scheduled, repeating gift (weekly, monthly, etc.), including the amount, the schedule, when the last gift came in, and when the next one is due. Recurring donations are read-only. Reach for this for questions about scheduled future giving ("who gives monthly?", "whose recurring gift is paused?", "what is this person's recurring gift?"). For gifts that have actually been received, use giving_donations instead. status is active, indefinite_hold (paused with no end date), or temporary_hold (paused until release_hold_at). Include designations to see how a recurring gift is split across funds. Each designation carries its fund as a relationship id, so use giving_funds to get fund names. The donor is likewise returned as a person id - use people_search to resolve names. amount_cents on the gift is its total across every fund it is split between, so it does not answer how much goes to one fund. For that, include designations and read the amount on the designation whose fund is the one in question.
giving_refunds
ChatGPTGet the refund on a single donation in Planning Center Giving - the amount refunded, the payment processing fee returned, and when the refund was processed. A donation has at most one refund. Requires a donation ID, so reach for this when a specific donation is already in hand and the question needs the refund record's own fields (the refund fee, the exact time the refund was processed). For aggregate questions like "how much did we refund last month?", use giving_donations to find refunded donations instead. A not-found result means the donation has no refund, the donation ID is invalid, or you don't have permission to manage donations in Giving (administrator or bookkeeper).
groups_event_attendances
ChatGPTLook up individual attendance records for a single event in Planning Center Groups - whether each person attended and their role (member, leader, visitor, or applicant) at the time of the event.
groups_events
ChatGPTSearch events in Planning Center Groups. An event is a single meeting of a group with a start and end time, an optional location, and a cancellation status. By default this searches events across every group in the organization. Provide group_id or person_id to list events for a specific group or person.
groups_group_types
ChatGPTList or fetch group type categories (e.g. "Small Groups", "Classes") from Planning Center Groups. Group types define the default settings, visibility, and color theme for the groups within them.
groups_memberships
ChatGPTLook up group memberships in Planning Center Groups - the association of a person to a group, with the member's role and the date they joined. Provide exactly one of group_id (to list a group's members) or person_id (to list the groups a person belongs to).
groups_search
ChatGPTSearch for groups. Groups are collections of people that meet together regularly (small groups, classes, Bible studies, etc.). Returns details like name, description, schedule, contact email, and membership count. Use groups_group_types to look up the categories that groups belong to.
people_background_checks
ChatGPTSearch for background checks in the currently logged in user's organization. Optionally filter by a specific person using person_id. Current denotes the background check that best represents a person's current standing
people_church_campuses
ChatGPTList the church campuses (physical sites) configured for the organization. The returned campus IDs are what the campus_id/campus_ids filters on other tools (e.g. people_search, groups_search) expect.
people_current_organization
ChatGPTGet information about the authenticated user's organization.
people_field_data
ChatGPTSearch for custom field data values in the currently logged in user's organization. A field datum is an individual piece of data for a custom field on a person's profile. Each field datum is tied to a field definition, which belongs to a custom tab on the profile. Use this tool to look up the values of custom fields for people.
people_field_definitions
ChatGPTSearch for custom field definitions configured in the currently logged in user's organization. A field definition represents a custom field — its name, data type, sequence, and which tab it belongs to. Use this tool to discover what custom fields are available on people profiles.
people_form_fields
ChatGPTSearch the fields that make up a specific people form. Each form field describes a single input on the form, including its label, field type, whether it is required, and its display order. Requires a form_id (find one via people_forms). Use this to understand a form's structure before reading its submissions with people_form_submissions or recording one with people_form_submissions_create.
people_form_submissions
ChatGPTSearch for people form submissions in the currently logged in user's organization. A form submission represents an individual person's response to a specific people form. Planning Center Form Submission link format: https://people.planningcenteronline.com/forms/FORM_ID/form_submissions/SUBMISSION_ID
people_form_submissions_create
ChatGPTRecord a submission to a people form, for submissions captured outside of Church Center (e.g. a paper form). The caller must be able to manage the target form. Identify the submitter with either person_id (an existing person) or person_attributes (matched to an existing profile by name + email, or used to create a new person). Provide exactly one of the two. Pass each answer in values, referencing a form_field_id on the form. The shape of value depends on the field's type, so use people_form_fields (include options) to discover each field's id, type, and option ids before submitting (the value field documents the exact shapes). Use people_forms to find the form and people_form_submissions to read existing submissions. IMPORTANT: Submit only answers supplied by the user, or values they explicitly asked you to look up. Never infer, guess, or fabricate a value -- if a required field's value is unknown, ask the user rather than supplying a placeholder. Submitting triggers the same side effects as a Church Center submission: notification and confirmation emails, workflow cards, and profile updates.
people_forms
ChatGPTSearch for people forms in the currently logged in user's organization. Forms is a tool for gathering information from people via customizable online forms. Planning Center Form link format: https://people.planningcenteronline.com/forms/FORM_ID
people_households
ChatGPTSearch for households and the people that are a part of them.
people_list_results
ChatGPTRetrieves the people that appear in a specific Planning Center People list. Planning Center List link format: https://people.planningcenteronline.com/lists/LIST_ID/list_results
people_lists
ChatGPTSearch for people lists in the currently logged in user's organization. A list is a powerful tool for finding and grouping people together. To get the people in a list, use the List Results tool. Planning Center List link format: https://people.planningcenteronline.com/lists/LIST_ID
people_note_categories
ChatGPTSearch note categories in Planning Center People. Note categories organize and classify notes on people profiles. Use this tool to find available note categories by name.
people_notes
ChatGPTSearch for notes attached to people's profiles in the currently logged in user's organization. A note is text with a category connected to a person's profile.
people_notes_create
ChatGPTCreate a note on a person's profile. A note is text filed under a note category and attached to a specific person. Use this to record a note about someone; use people_notes to read existing notes and people_note_categories to discover which category to file the note under.
people_organization
ChatGPTGet currently logged in user's organization information including: organization name, timezone, country, contact website, avatar url, grades, church center sub-domain etc.
people_search
ChatGPTSearch for people in the currently logged in user's organization. Planning Center People link format: https://people.planningcenteronline.com/people/AC[USER_ID]
people_tabs
ChatGPTSearch for people tabs in the currently logged in user's organization. A tab is a custom tab that groups field definitions (e.g., 'Volunteer Info', 'Medical').
people_workflow_cards
ChatGPTSearch for people workflow cards in the currently logged in user's organization. Cards are workflow steps that are assigned to a staff member to perform for a specific person.
people_workflow_categories
ChatGPTSearch for categories that are associated to people workflows
people_workflows
ChatGPTSearch for people workflows in the currently logged in user's organization. A workflow consists of a series of steps to complete a specific task (e.g. Baptism Interest would entail scheduling a meeting, provide learning materials, assign dates, etc.). Steps consist of cards that are a step that is assigned to a staff member to perform for a specific person. Planning Center Workflow link format: https://people.planningcenteronline.com/workflows/WORKFLOW_ID
publishing_channels
ChatGPTSearch sermon channels in Planning Center Publishing. A "channel" is a top-level content grouping for sermons (e.g. "Sunday Morning", "Wednesday Bible Study"). Each channel carries its own feature flags (enable_audio, enable_on_demand_video, enable_watch_live, general_chat_enabled/group_chat_enabled, sermon_notes_enabled, podcast configuration) and a lifecycle pair (published, archived). This is the foundational Publishing tool. publishing_episode_statistics requires a channel id from here. publishing_episodes and publishing_series can't filter by channel — request their channel include and group by it client-side. For lifecycle questions ("is this channel published or archived?", "show me archived channels") use the filter param (archived, not_archived, published, podcast_enabled) rather than fetching every channel and inspecting the published/archived attributes yourself — the filter dispatches server-side. Pass multiple values to combine scopes, e.g. ["published", "podcast_enabled"] for published channels with podcasting enabled. A channel's services_service_type_remote_identifier links it to a Planning Center Services service type. To answer "which channel is paired with our Sunday 9am service type?", call services_service_types first to find that service type's id, then match it against a channel's services_service_type_remote_identifier here. general_chat_enabled/group_chat_enabled read false both when chat is off and when the org lacks a Groups subscription; check can_enable_chat to tell those two cases apart.
publishing_episode_statistics
ChatGPTChurch Center viewership statistics for the episodes in a single Publishing channel. Returns one entry per episode with its Church Center live watch count (live_watch_count), library watch count (library_watch_count), and a per-EpisodeTime breakdown (times, each carrying its own watch_count). Counts are Church Center plays only. Views on YouTube, Vimeo, Facebook, or other external platforms are NOT included — this mirrors the per-episode statistics panel the Publishing admin sees. This tool takes a channel_id. First call publishing_channels to pick the relevant channel (typically the main Sunday channel), then call this tool with that channel's id. Answer questions like "most-watched episodes this month" or "average listen count per episode" by fetching a channel's statistics and aggregating client-side — do NOT fan out per episode. Aggregates cover only the episodes you have fetched, so set per_page to 100 and keep paging with page_after until has_more is false before summarizing. Use type and the after/before date range to narrow server-side: type: "live" bounds by when episodes were published live, type: "library" bounds by when they were added to the library, and omitting type returns episodes matching either. after is an inclusive lower bound (includes the whole named day). before is an exclusive upper bound: it cuts off at the start of the named day, so episodes published on the before date itself are NOT included. Both are YYYY-MM-DD.
publishing_episodes
ChatGPTSearch episodes in Planning Center Publishing. An episode is a single sermon — it carries title, description, art, audio/video URLs (both live-stream and on-demand library), and publication timestamps (published_live_at, published_to_library_at). Use search to find sermons by topic, book, or passage (e.g. "sermons on Romans") — it matches against the episode's title only (not description, and not speaker or preacher name). Use church_center_url for a link to the episode on Church Center. page_actions is intentionally not exposed — two of its three actions are admin-write actions (remove from series, edit); church_center_url covers the one navigation action. Cross-product chaining: an episode carries services_plan_remote_identifier (the Services Plan that was live for this sermon) and services_service_type_remote_identifier (the Services Service Type its channel is paired with) — resolve a plan or service type id from services_plans / services_service_types first, then pass it here (e.g. "last Sunday's sermon" resolves by first finding the Sunday-service plan, then matching its id here). Filter by series_id to get all episodes in a sermon series — resolve the series by name with publishing_series first, then pass its id here. Filter by speaker with speaker_id and speaker_type together — both are required (a speaker id alone is ambiguous because a Person and a Guest can share the same id). Resolve them from publishing_speakers first, which returns each speaker's id and speaker_type, then pass both here. For a prompt naming both a speaker and a topic (e.g. "Find Pastor John's sermons on Romans"), resolve the speaker via publishing_speakers, then call this tool with the speaker pair plus search on the topic ({"speaker_id": "...", "speaker_type": "Person", "search": "Romans"}). To surface the most recent sermons, pair order_by: -published_live_at with filter: published_live. Without the filter, episodes that never went live or are only scheduled can sort above the genuinely most-recent sermons. Only add the filter when the user wants sermons that have already aired; omit it to sort across all episodes.
publishing_series
ChatGPTSearch sermon series in Planning Center Publishing. A "series" is a collection of episodes organized around a theme (e.g. "Romans", "Easter", "Advent"), scoped to a single channel. Each series carries a title, description, art, the run window (started_at / ended_at), an episodes_count, and a published lifecycle flag. Use this tool for questions about series metadata: "what's the current sermon series?", "how many episodes are in the Romans series?", "show me all the series we've done this year". Filter by title with the title param (partial match on the series title). For lifecycle questions use the filter param ("published", "not_published", "published_on_church_center") rather than fetching every series and inspecting the published attribute yourself — the filter dispatches server-side. Pass multiple values to combine scopes. To find the current series, request filter=["published"] with order_by="-started_at", then pick the most recent series whose window covers today (started_at on or before today, and ended_at empty or on/after today) — there is no server-side "current" filter. To list the episodes within a series, resolve the series id here first, then pass it to publishing_episodes as series_id.
publishing_speakers
ChatGPTSearch speakers in Planning Center Publishing. A "speaker" is a unified abstraction over two underlying record types, distinguished by speaker_type: "Person" (a PCO People record) or "Guest" (an ad-hoc record for external speakers with no People record). Use search to resolve name-based prompts directly, e.g. "has Pastor John preached recently?" → search: "John". For sermon-content questions about a specific speaker, resolve the speaker's id and speaker_type here first, then chain both into publishing_episodes's speaker_id and speaker_type filters (both are required together) to find their sermons. For "Person" speakers, id is the same People account-center id people_search returns, so you can alternatively resolve via people_search first and match the account-center id against a speaker here. "Guest" speakers only exist in Publishing — they have no People record, so people_search will never find them, and the response has no links.html for them (Person speakers do have one, pointing at the People record). Requires Publishing administrator access; other org members will get a permission error.
registrations_attendees
ChatGPTSearch the attendees registered for a specific Planning Center signup. An attendee is a person registered for a signup, with status flags for whether they are active, canceled, complete, or waitlisted. For simple signups, attendees are not linked to individual person records, so person will be null.
registrations_registrations
ChatGPTSearch registrations for a specific signup. A registration is a single submission to a signup.
registrations_signups
ChatGPTSearch signups. A signup is an ongoing program, opportunity, or event that people can register for.
services_blockouts
ChatGPTSearch the blockout dates for a specific person. A blockout is a date or recurring date range when a person is unavailable to be scheduled to serve (e.g. vacation or a regular weekly conflict), optionally with a recurrence pattern. Requires a person_id; returns that person's blockouts including start/end times and any repeat settings.
services_plan_items
ChatGPTSearch the items (the order of service) within a specific plan in Planning Center Services. Each item is one element in a plan's sequence — a song, header, media, or announcement — with its title, type, length, key, and service position. Requires a service_type_id and a plan_id; items are returned in their plan sequence order.
services_plan_people
ChatGPTList the people scheduled to serve on a specific plan in Planning Center Services — the plan's roster. Each entry includes the person's name, the team and position they're filling, and their confirmation status (confirmed, unconfirmed, or declined). Requires a service_type_id and a plan_id. Use this to answer "who is serving on this plan, and who hasn't confirmed yet?"; pass filter or read each person's status to narrow by confirmation state. For an individual's cross-plan schedule, use the schedules tool instead.
services_plans
ChatGPTSearch plans within a Planning Center Services service type. A plan is a single worship service or event (e.g. "Sunday Morning, June 8") containing its dates, series, item and people counts, length, and links, along with its service and rehearsal times. Requires a service_type_id (find one via the services_service_types tool). Use this to list a service type's plans or find a specific plan by title or series. Optionally include the plan's times, series, contributors, or the authenticated user's own schedules. sort_date is the plan's service date, and plans are commonly scheduled into the future, so ordering by -sort_date alone returns the next upcoming plan rather than the last one held. To find the most recent service, combine filter "past" with order_by -sort_date — the first result is the latest plan on or before today. A plan's title is frequently null; identify a plan by its dates (or series_title) when it is.
services_schedules
ChatGPTRetrieve a person's schedule in Planning Center Services — the worship service plans they are scheduled to serve in, including the dates, the team and position they're filling, the service type, and their confirmation status (e.g. confirmed, unconfirmed, declined). Defaults to the authenticated user's own schedule when person_id is omitted, so this answers "what am I scheduled for". Provide a person_id (find one via the People search tool) to look up someone else's schedule.
services_service_types
ChatGPTSearch for service types. A Service Type is a container for plans, typically a recurring worship event like Sunday AM, Wednesday Service, or Christmas Eve. Service Types group all the plans, teams, schedules, and song lists for that service.
services_songs
ChatGPTSearch the Planning Center Services song library. A song is a reusable piece of music (title, author, CCLI number, copyright, and themes) that can be scheduled into service plans. Use this to find songs by title, author, theme, or CCLI number, or to browse the library.
services_team_positions
ChatGPTSearch the team positions within a service type in Planning Center Services. A team position is a role within a team that people are scheduled into — for example "Acoustic Guitar", "Vocals", or "Camera 1". Requires a service_type_id; positions are returned with their name and sequence, and can include their parent team or assigned tags.
services_teams
ChatGPTSearch teams in Planning Center Services. A team is a group within a service type that people are scheduled into to serve (e.g. Band, Vocals, Production, Hospitality), including its name, scheduling settings, and the service types it belongs to. Use this to discover what teams exist or to find a specific team by name. Pass a service_type_id to limit results to a single service type, or omit it to search across the whole organization. Optionally include the team's people, positions, leaders, or service types.
groups_event_attendances
Claudegroups_events
Claudegroups_group_types
Claudegroups_memberships
Claudegroups_search
Claudepeople_background_checks
Claudepeople_church_campuses
Claudepeople_current_organization
Claudepeople_field_data
Claudepeople_field_definitions
Claudepeople_form_fields
Claudepeople_form_submissions
Claudepeople_form_submissions_create
Claudepeople_forms
Claudepeople_households
Claudepeople_list_results
Claudepeople_lists
Claudepeople_note_categories
Claudepeople_notes
Claudepeople_notes_create
Claudepeople_search
Claudepeople_tabs
Claudepeople_workflow_cards
Claudepeople_workflow_categories
Claudepeople_workflows
Clauderegistrations_attendees
Clauderegistrations_registrations
Clauderegistrations_signups
Claudeservices_blockouts
Claudeservices_plan_items
Claudeservices_plan_people
Claudeservices_plans
Claudeservices_schedules
Claudeservices_service_types
Claudeservices_songs
Claudeservices_team_positions
Claudeservices_teams
Claude
