# Returns a list of records with the specified program_id

Returns a list of records with the specified program_id

Endpoint: GET /applicationProcesses/{tenantId}/program/{program_id}
Version: v1-2025-04-18
Security: knox-authorizer

## Path parameters:

  - `tenantId` (string, required)
    The tenant

  - `program_id` (string, required)
    The program_id to use to for record lookup

## Query parameters:

  - `fields` (string)
    The fields that you want to retrieve; if omitted, the entire object is returned

  - `exclusiveStartKey` (string)
    If paging, this allows you to return the next set of results

## Response 200 fields (application/json):

  - `Count` (integer)

  - `Items` (array)

  - `Items.allow_applicants_to_update_in_portal` (boolean)
    Allow for applicants to update the application while it is under review

  - `Items.applicant_update_options` (object, required)

  - `Items.applicant_update_options.update_form_id` (string, required)
    The certification application form for updating

  - `Items.application_confirmation_email_options` (object, required)

  - `Items.application_confirmation_email_options.application_confirmation_email` (object)
    The email to send when the application is received

  - `Items.application_confirmation_email_options.application_confirmation_email.bcc` (string)
    Anyone that should be bcc'ed on the email

  - `Items.application_confirmation_email_options.application_confirmation_email.body` (string, required)
    The email body

  - `Items.application_confirmation_email_options.application_confirmation_email.cc` (string)
    Anyone that should be cc'ed on the email

  - `Items.application_confirmation_email_options.application_confirmation_email.from` (string)
    From email address

  - `Items.application_confirmation_email_options.application_confirmation_email.from_name` (string)
    From name

  - `Items.application_confirmation_email_options.application_confirmation_email.reply_to` (string)
    The reply to

  - `Items.application_confirmation_email_options.application_confirmation_email.subject` (string, required)
    The email subject

  - `Items.application_confirmation_email_options.application_notice_id` (string)
    The application notice to use

  - `Items.application_confirmation_email_options.type` (string, required)
    The type of confirmation email to use
    Enum: "application notice", "specific email"

  - `Items.application_expiration_rule_set_id` (string)
    The rule set for calculating the expiration of an application submitted by this process

  - `Items.application_form_id` (string, required)
    The certification application form

  - `Items.automatically_approve_applications_once_requirements_are_met` (boolean)
    If true, applications in this process are marked approved once requirements are met. Otherwise they are pending approval

  - `Items.available_to_training_providers` (boolean)
    If true, this process is available to training providers

  - `Items.certification_activation_email_options` (object, required)

  - `Items.certification_activation_email_options.certification_activation_email` (object)
    The email to send when the certification is activated

  - `Items.checkout_settings` (object, required)

  - `Items.checkout_settings.allow_customer_to_choose_installment_plan` (boolean)
    If true, the customer can choose their installment plan

  - `Items.checkout_settings.bank_account_id` (string, required)
    The default bank account that the store should use to receive payments

  - `Items.checkout_settings.bill_my_organization_options` (object)

  - `Items.checkout_settings.bill_my_organization_options.billing_address` (string)
    Enum: "do not show", "optional", "required"

  - `Items.checkout_settings.bill_my_organization_options.purchase_order_number` (string)
    Enum: "do not show", "optional", "required"

  - `Items.checkout_settings.bill_my_organization_options.reference_number` (string)
    The reference #

  - `Items.checkout_settings.bill_my_parent_organization_options` (object)

  - `Items.checkout_settings.business_unit_id` (string, required)
    The business unit of the store

  - `Items.checkout_settings.cancellation_fee_product_id` (string)
    The ID of the product used for cancellation fees

  - `Items.checkout_settings.checkout_donation_options` (object)

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options` (object)

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.allow_user_to_specify_custom_amount` (boolean)
    If set, the user can specify their own custom donation

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.donation_ask_text` (string)
    The text shown to the user when making the donation

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.donation_denominations` (array)

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.donation_information` (string)
    Additional information about the donation

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.donation_product_id` (string, required)
    The misc product that should be used

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.override_donation_denominations` (boolean)
    If set, donation denominations are specified here and the defaults are not used

  - `Items.checkout_settings.checkout_donation_options.simple_checkout_donation_options.suggested_donation` (number)
    A suggested donation

  - `Items.checkout_settings.checkout_donation_options.type` (string)
    Enum: "simple"

  - `Items.checkout_settings.credit_card_minimum_range_end` (number)
    If set, the maximum amount for which credit cards can be taken

  - `Items.checkout_settings.credit_card_minimum_range_start` (number)
    If set, the minimum amount for which credit cards can be taken

  - `Items.checkout_settings.credit_card_mode` (string)
    Determines whether or not credit cards are accepted
    Enum: "disabled", "enabled", "range"

  - `Items.checkout_settings.credit_card_processing_fee_mode` (string)
    Determines how credit card processing fees should be handled
    Enum: "charge", "do not charge", "prompt user"

  - `Items.checkout_settings.credit_card_processing_fee_options` (object)

  - `Items.checkout_settings.credit_card_processing_fee_options.fee_percentage` (number, required)
    The fee percentage to charge for credit card processing

  - `Items.checkout_settings.credit_card_processing_fee_options.maximum_fee` (number)
    The maximum amount to charge. If the fee comes out to be MORE than this, than this amount will be charged

  - `Items.checkout_settings.credit_card_processing_fee_options.minimum_fee` (number)
    The minimum amount to charge. If the fee comes out to be less than this, than this amount will be charged

  - `Items.checkout_settings.credit_card_processing_fee_options.product_id` (string, required)
    The misc product to use for the credit card processing

  - `Items.checkout_settings.credit_card_processing_fee_options.prompt_sub_text` (string)
    Additional text that is shown to the user when asking if they want to pay for credit card processing fees. If not set a default will be used

  - `Items.checkout_settings.credit_card_processing_fee_options.prompt_text` (string)
    The checkbox text to show the user when asking if they want to pay for credit card processing fees. If not set a default will be used

  - `Items.checkout_settings.custom_order_preprocessing_options` (object)

  - `Items.checkout_settings.custom_order_preprocessing_options.lambda_function_id` (string, required)
    The custom lambda function to use

  - `Items.checkout_settings.custom_order_pricing_options` (object)

  - `Items.checkout_settings.disable_electronic_payment_vaulting` (boolean)
    If set, in the portal people are not allowed to save credit cards

  - `Items.checkout_settings.enable_bill_my_organization` (boolean)
    If set, the user has the option to bill their organization

  - `Items.checkout_settings.enable_bill_my_parent_organization` (boolean)
    If set, the user has the option to bill their organization's parent organization

  - `Items.checkout_settings.enable_custom_order_preprocessing` (boolean)
    If set, the order engine will call out to a custom lambda function to process/change the order immediately after bundle expansion

  - `Items.checkout_settings.enable_custom_order_pricing` (boolean)
    If set, the order engine will call out to a custom lambda function to review the order immediately after pricing calculation

  - `Items.checkout_settings.enable_donations_at_checkout` (boolean)
    If selected, users will be prompted to make a donation upon checking out

  - `Items.checkout_settings.enable_electronic_checks` (boolean)
    If set, electronic checks are allowed

  - `Items.checkout_settings.enable_pay_later` (boolean)
    If set, pay later is enabled on this checkout regardless of product settings... if not, the product settings are observed

  - `Items.checkout_settings.enable_payroll_deduction` (boolean)
    If set, payroll deduction is allowed

  - `Items.checkout_settings.enable_split_payments` (boolean)
    If set, users are allowed to split payments

  - `Items.checkout_settings.installment_plan_options` (array)

  - `Items.checkout_settings.invoice_payment_terms_id` (string)
    The payment terms for invoices; if left blank, default is used

  - `Items.checkout_settings.invoice_template_id` (string)
    The template to use for invoices created during this process

  - `Items.checkout_settings.merchant_account_id` (string, required)
    The merchant account that the store should use to receive payments

  - `Items.checkout_settings.pay_later_options` (object)

  - `Items.checkout_settings.restocking_fee_product_id` (string)
    The ID of the product used for restocking fees

  - `Items.checkout_settings.special_instructions` (string)
    Instructions shown to the user

  - `Items.checkout_settings.use_pro_forma_invoices` (boolean)
    Whether to use pro forma invoices when user elects to pay later

  - `Items.contact_form_options` (object, required)

  - `Items.contact_form_options.contact_form_id` (string, required)
    The default contact form to present to the user to verify the contact info before proceeding

  - `Items.contact_form_options.html` (string)
    Text to show on the top of the form

  - `Items.course_registration_options` (object, required)

  - `Items.course_registration_options.course_registration_process_id` (string, required)
    The process to use when registering for courses, which tells us the email to send

  - `Items.customer_type` (string, required)
    Enum: "contact", "organization"

  - `Items.description` (string)
    A description of the process

  - `Items.display_in_portal` (boolean)
    Whether or not to hide in the portal

  - `Items.display_in_portal_as` (string)
    How to display this process in the portal

  - `Items.display_order` (number)
    Optional order to display the process

  - `Items.eligibility_criteria` (object, required)
    The criteria to use

  - `Items.eligibility_criteria.advanced_rule_error_message` (string)
    The error message to show when the advanced rule fails

  - `Items.eligibility_criteria.advanced_rules` (object)

  - `Items.eligibility_criteria.age_restrictions` (object)

  - `Items.eligibility_criteria.age_restrictions.maximum_age` (number)
    The maximum age of the contact

  - `Items.eligibility_criteria.age_restrictions.minimum_age` (number)
    The minimum age of the contact

  - `Items.eligibility_criteria.award_options` (object)

  - `Items.eligibility_criteria.award_options.award_ids` (array)

  - `Items.eligibility_criteria.award_options.award_type_ids` (array)

  - `Items.eligibility_criteria.award_options.logic_operator` (string)
    Enum: "and", "not"

  - `Items.eligibility_criteria.award_recipients` (boolean)
    If set, only people who have received awards

  - `Items.eligibility_criteria.by_location` (boolean)
    If true, then filter by location

  - `Items.eligibility_criteria.certificants` (boolean)
    If set, only people with specific certifications

  - `Items.eligibility_criteria.certification_options` (object)

  - `Items.eligibility_criteria.certification_options.program_ids` (array)

  - `Items.eligibility_criteria.committee_member_options` (object)

  - `Items.eligibility_criteria.committee_member_options.committee_ids` (array)

  - `Items.eligibility_criteria.committee_member_options.committee_position_ids` (array)

  - `Items.eligibility_criteria.committee_member_options.committee_type_ids` (array)

  - `Items.eligibility_criteria.committee_members` (boolean)
    If set, active members who belong to a committee can purchase

  - `Items.eligibility_criteria.custom_logic_options` (object)

  - `Items.eligibility_criteria.donor_options` (object)

  - `Items.eligibility_criteria.donor_options.donor_club_ids` (array)

  - `Items.eligibility_criteria.donors` (boolean)
    If true, only donors

  - `Items.eligibility_criteria.enable_advanced_rules` (boolean)
    Enable advanced JSON rules

  - `Items.eligibility_criteria.enable_age_restrictions` (boolean)
    Age registrations

  - `Items.eligibility_criteria.enable_custom_logic` (boolean)
    If set, the order engine will call out to a custom lambda function to process/change the order immediately after bundle expansion

  - `Items.eligibility_criteria.enable_entitlement_restrictions` (boolean)
    If set, then you must have certain entitlements

  - `Items.eligibility_criteria.enable_expression` (boolean)
    Whether or not to enable an expression for evaluation

  - `Items.eligibility_criteria.enable_organization_restrictions` (boolean)
    If set, you can restrict organizations

  - `Items.eligibility_criteria.enable_status_restriction` (boolean)
    If set, you can restrict by status

  - `Items.eligibility_criteria.entitlement_restrictions` (array)

  - `Items.eligibility_criteria.entitlement_restrictions.quantity` (number)
    The quantity you must have

  - `Items.eligibility_criteria.entitlement_restrictions.type_id` (string, required)
    The type of entitlement

  - `Items.eligibility_criteria.event_registration_options` (object)

  - `Items.eligibility_criteria.event_registration_options.event_ids` (array)

  - `Items.eligibility_criteria.event_registration_options.registration_category_ids` (array)

  - `Items.eligibility_criteria.event_registrations` (boolean)
    If set, only people who have registered for events

  - `Items.eligibility_criteria.expression` (string)
    The expression

  - `Items.eligibility_criteria.expression_error_message` (string)
    The error message to show when the expression fails

  - `Items.eligibility_criteria.location` (object)

  - `Items.eligibility_criteria.location.countries` (array)
    Countries

  - `Items.eligibility_criteria.location.negate_logic` (boolean)
    If true, the logic in this section is negated; so NOT from these places

  - `Items.eligibility_criteria.member_options` (object)

  - `Items.eligibility_criteria.member_options.chapter_member_options` (object)

  - `Items.eligibility_criteria.member_options.chapter_member_options.chapter_ids` (array)

  - `Items.eligibility_criteria.member_options.chapter_member_options.chapter_type_ids` (array)

  - `Items.eligibility_criteria.member_options.chapter_members` (boolean)
    If set, active members who belong to a chapter can purchase

  - `Items.eligibility_criteria.member_options.member_package_ids` (array)
    The member package

  - `Items.eligibility_criteria.member_options.member_status_reason_ids` (array)

  - `Items.eligibility_criteria.member_options.member_statuses` (array)
    Enum: "active", "inactive", "suspended"

  - `Items.eligibility_criteria.member_options.member_type_ids` (array)
    The member types

  - `Items.eligibility_criteria.member_options.section_member_options` (object)

  - `Items.eligibility_criteria.member_options.section_member_options.section_ids` (array)

  - `Items.eligibility_criteria.member_options.section_member_options.section_type_ids` (array)

  - `Items.eligibility_criteria.member_options.section_members` (boolean)
    If set, active members who belong to a section can purchase

  - `Items.eligibility_criteria.members` (boolean)
    If set, active members can purchase this

  - `Items.eligibility_criteria.non_members` (boolean)
    If set, only nonmembers can purchase

  - `Items.eligibility_criteria.organization_restrictions` (object)

  - `Items.eligibility_criteria.organization_restrictions.contact_role_ids` (array)

  - `Items.eligibility_criteria.organization_restrictions.organization_type_ids` (array)

  - `Items.eligibility_criteria.status_restrictions` (array)
    The statuses

  - `Items.eligibility_criteria.use_organization_for_eligibility` (boolean)
    If checked, a person's organization is used to check for eligibility, rather than the person themselves

  - `Items.enable_application_confirmation_email` (boolean)
    Whether or not an email should be sent when the application is received

  - `Items.enable_certification_activation_email` (boolean)
    Whether or not to send an email when the certification is actually activated

  - `Items.enable_course_registration` (boolean)
    If true, users can register for courses while applying for the certification

  - `Items.enable_eligibility_criteria` (boolean)
    If true, only certain eligible persons can proceed with this process

  - `Items.enable_exam_registration` (boolean)
    If true, users can register for exams while applying for the certification

  - `Items.enable_grandfather_restrictions` (boolean)
    Only people who are grandfathered into other certification programs may complete this process

  - `Items.exam_registration_options` (object, required)

  - `Items.exam_registration_options.exam_registration_process_id` (string, required)
    The process to use when registering for exams, which tells us the email to send

  - `Items.expiration_rule_set_id` (string, required)
    The rule set for calculating the expiration of a certification generated by this process

  - `Items.fee_id` (string)
    The baseline fee

  - `Items.grandfather_restrictions` (object, required)

  - `Items.grandfather_restrictions.certification_program_ids` (array, required)
    The programs that a person must have an active, grandfather certification in order to complete this process

  - `Items.grandfather_restrictions.invert_logic` (boolean)
    If true, then this process will be available if a person does NOT have one of the grandfathered certs

  - `Items.id` (string, required)
    The unique, string identifier of this process

  - `Items.is_active` (boolean)
    Whether or not this process is active

  - `Items.name` (string, required)
    The name of the process

  - `Items.organization_form_options` (object, required)

  - `Items.organization_form_options.organization_form_id` (string, required)
    The default organization form to present to the user to verify the organization info before proceeding

  - `Items.override_checkout_settings` (boolean)
    Whether or not to override POC settings

  - `Items.prefill_application_with_profile_information` (boolean)
    If true, data stored in the certification profile is used as the starting point for the application

  - `Items.program_id` (string, required)
    The program to which this process is tied

  - `Items.reinstatement_options` (object, required)

  - `Items.reinstatement_options.reinstatement_period` (number)
    Number of days after termination after which a person can be reinstated - leave blank for an indefinite time period

  - `Items.renewal_options` (object, required)

  - `Items.renewal_options.renewal_window` (number, required)
    The number of days prior to expiration this person is allowed to renew

  - `Items.requirements` (array)

  - `Items.requirements.course_requirements` (object)

  - `Items.requirements.course_requirements.attendance_required` (boolean)
    If true, then only course registrations with a status of attended will be considered to have met this requirement

  - `Items.requirements.course_requirements.course_ids` (array, required)
    The required courses; a user fulfills this requirement by taking any of these courses

  - `Items.requirements.course_requirements.hide_during_application_process` (boolean)
    If, set, then during the application process this course is not displayed for selection

  - `Items.requirements.course_requirements.time_frame` (object)
    The timeframe in which the course needs to have been taken

  - `Items.requirements.course_requirements.time_frame.number` (number, required)
    The unit of time

  - `Items.requirements.course_requirements.time_frame.position` (string, required)
    How the unit relates to the reference date
    Enum: "after", "before", "on"

  - `Items.requirements.course_requirements.time_frame.relative_to` (string, required)
    Enum: "the beginning of the month", "the beginning of the quarter", "the beginning of the week", "the beginning of the year", "the end of the month", "the end of the quarter", "the end of the week", "the end of the year", "the reference date"

  - `Items.requirements.course_requirements.time_frame.unit_of_time` (string, required)
    Enum: "days", "months", "weeks", "years"

  - `Items.requirements.credit_requirements` (object)

  - `Items.requirements.credit_requirements.credit_type_id` (string, required)
    The type of credits required

  - `Items.requirements.credit_requirements.do_not_allow_reuse` (boolean)
    If true, a credit used by this requirement cannot be reused elsewhere

  - `Items.requirements.credit_requirements.formula` (string)
    A formula to determine the number of credits

  - `Items.requirements.credit_requirements.number_of_credits` (number)
    The number of credits required

  - `Items.requirements.credit_requirements.restrict_certain_activity_types` (boolean)
    If true, credits gained by certain activities are NOT allowed to be counted to fulfilling requirements

  - `Items.requirements.credit_requirements.restricted_activity_type_ids` (array)
    Credits gained from these activities will not be counted towards requirements

  - `Items.requirements.credit_requirements.type` (string)
    Whether or not the number of credits is fixed or calculated
    Enum: "calculated", "fixed"

  - `Items.requirements.enable_partial_applicability` (boolean)
    If true, this requirement is only applied to a subset of applicants

  - `Items.requirements.exam_requirements` (object)

  - `Items.requirements.exam_requirements.exam_ids` (array, required)
    The required exams; a user fulfills this requirement by taking any of these exams

  - `Items.requirements.exam_requirements.time_frame` (object)
    The timeframe in which the exam needs to have been taken

  - `Items.requirements.expression_requirements` (object)

  - `Items.requirements.expression_requirements.expression` (string, required)
    An optional expression to be used to determine whether or not the requirement is met

  - `Items.requirements.field_requirements` (object)

  - `Items.requirements.field_requirements.mapped_field` (string, required)
    The field to be used in determining whether this requirement has been met

  - `Items.requirements.id` (string, required)
    The unique, string identifier of the requirement

  - `Items.requirements.name` (string, required)
    The name of the requirement

  - `Items.requirements.partial_applicability_options` (object)

  - `Items.requirements.partial_applicability_options.percentage` (number, required)
    The % of applicants that should have this rule applied to them

  - `Items.requirements.portal_explanation` (string)
    An optional explanation to display in the portal

  - `Items.requirements.reference_requirements` (object)

  - `Items.requirements.reference_requirements.number_of_references` (number, required)
    The number of references

  - `Items.requirements.reference_requirements.reference_process_id` (string, required)
    The reference process

  - `Items.requirements.reference_requirements.reference_type_id` (string, required)
    The type of reference

  - `Items.requirements.weight` (number)
    For the purposes of displaying completeness, the weight which you assign this requirement

  - `Items.restrict_organization_types` (boolean)
    Restrict to certain types of organizations

  - `Items.show_contact_form` (boolean)
    Whether or not to show a contact form

  - `Items.show_organization_form` (boolean)
    Whether or not to show an organization form

  - `Items.sys_bulk_load_at` (string)
    If this record was loaded via bulk, the timestamp when the record was processed

  - `Items.sys_bulk_load_id` (string)
    If this record was loaded via bulk, the ID of the bulk load process

  - `Items.sys_bulk_load_pk` (string)
    If this record was loaded via bulk, the tenant and key of the bulk load process used as a partition key

  - `Items.sys_bulk_load_record_no` (number)
    If this record was loaded via bulk, the record number in the source file

  - `Items.sys_bulk_load_source_file` (string)
    If this record was loaded via bulk, the source file

  - `Items.sys_calculated_field_error` (string)
    The error associated with the calculated field

  - `Items.sys_calculated_field_errors` (array)

  - `Items.sys_calculated_field_errors.error` (string)

  - `Items.sys_calculated_field_errors.field` (string)

  - `Items.sys_configuration_snapshot_id` (string)
    If a snapshot was restored/applies to this record, the ID of the snapshot

  - `Items.sys_created_at` (string, required)
    The date/time that this record was created, expressed in ISO-8601 date format

  - `Items.sys_created_by_id` (string, required)
    The ID of the user that created this record

  - `Items.sys_deleted_by_id` (string)
    The ID of the user that deleted (or last tried to delete) this object

  - `Items.sys_directive` (string)
    Means for passing directive information into an object processing logic

  - `Items.sys_external_id` (string)
    The ID that a record has from an external system or data import

  - `Items.sys_has_files_in_s3` (boolean)
    If true, this record has files in S3. If false, it doesnt, so no need to hit S3 upon deletion

  - `Items.sys_last_bulk_data_operation_id` (string)
    If this record was last touched by a bulk data operation, the ID of that operation

  - `Items.sys_last_bulk_data_operation_sys_version` (string)
    If this record was last touched by a bulk data operation, the sys_version at the time of that operation

  - `Items.sys_last_modified_at` (string, required)
    The date/time that this record record was last modified, expressed in ISO-8601 date format

  - `Items.sys_last_modified_by_id` (string, required)
    The ID of the user that last modified this record

  - `Items.sys_last_security_context` (object)
    The security context of the last insert, modify, or delete performed on this item

  - `Items.sys_locked` (boolean)
    If set, this record is locked and cannot be changed via the API

  - `Items.sys_snapshot_base_version` (number)
    The version to use as a base when creating a configuration snapshot; if not set, 1 is used. Helpful when creating a sandbox

  - `Items.sys_version` (number)
    A number representing the version of this record in the database

  - `Items.transfer_options` (object)

  - `Items.transfer_options.allowed_program_ids` (array)
    The programs that are allowed to be transferred into; blank for all

  - `LastEvaluatedKey` (string)


## Response 400 fields

## Response 401 fields

## Response 403 fields

## Response 404 fields

## Response 429 fields

## Response 500 fields