Full Enrollment Flow

This guide demonstrates the complete flow for processing a single applicant through the Alleviate API, from credit report pull through final enrollment.

1. Authenticate - Obtain an access token from Azure AD
2. Pull Credit Report - Retrieve the applicant’s credit data
3. Check Eligibility - Determine which debts qualify for the program
4. Update Eligibility (Optional) - Modify applicant info or debt selections
5. Generate Offers - Create payment plan options
6. Create Offer - Save the selected payment plan
7. Create Enrollment - Create the client file in the CRM
8. Check Enrollment Status - Monitor enrollment progress

Step 1: Authenticate

Obtain an access token using OAuth 2.0 client credentials flow. The token is used as a Bearer token for all subsequent API requests.

Tip

See the Authentication Guide for detailed setup instructions and credentials.

Step 2: Pull Credit Report

Call the Credit API to pull the applicant’s credit report.

Endpoint: https://debt-core-api-sandbox.alleviate.com/credit-service/graphql

mutation PullCreditReport($input: PullCreditReportInput!) {
  pullCreditReport(input: $input) {
    data {
      creditReportId
      reqOrgContactId
      source
      reportStatus
      fileStatus
      leadId
    }
    errors {
      message
    }
  }
}

Variables:

{
  "input": {
    "reqOrgContactId": "<your-contact-id>",
    "creditReportSource": "ARRAY_EQUIFAX",
    "firstName": "THOMAS",
    "lastName": "DEVOS",
    "ssn": "666023511",
    "dob": "1957-09-06",
    "addressLine1": "BEAR CREEK RD",
    "addressLine2": "APT 110",
    "city": "TUSCALOOSA",
    "state": "AL",
    "zip": "35405"
  }
}

Note

Store the creditReportId from the response - you’ll need it for the eligibility check.

Step 3: Check Applicant Eligibility

Use the Underwriting API to check eligibility using the credit report.

Endpoint: https://debt-core-api-sandbox.alleviate.com/underwriting-service/graphql

mutation CheckApplicantEligibility(
  $applicationType: ApplicationTypeInput!
  $input: UwResultCheckInput!
) {
  checkApplicantEligibility(applicationType: $applicationType, input: $input) {
    data {
      id
      revision
      applicationUwResult {
        applicantPrequalified
        applicationType
        totalDebt
        totalEligibleDebt
        rootFilters {
          totalDebtValueCheck
          tenPercentRuleCheck
          agentAssignedCheck
          creditReport30DaysCheck
          psStateServiceCheck
          programTermCheck
          budgetHardshipCheck
        }
      }
      applicantUwResult {
        id
        debts {
          id
          accountNumber
          creditorName
          currentBalance
          eligibilityStatus
          isSelected
        }
      }
    }
    errors {
      debtId
      filterName
      message
    }
  }
}

Variables:

{
  "applicationType": "SINGLE",
  "input": {
    "primaryReportId": "{{creditReportId}}",
    "applicantContactInfo": {
      "firstName": "JOHN",
      "lastName": "DOE",
      "applicantState": "CA",
      "homeAddress": "123 Main St",
      "ssn": "123456789",
      "dob": "1980-01-15",
      "phone": "5555555555",
      "email": "john.doe@example.com",
      "employerName": "Acme Corp",
      "jobTitle": "Engineer",
      "routingNumber": "121000248",
      "bankName": "Wells Fargo",
      "bankAccountNumber": "1234567890",
      "bankAccountType": "checking"
    }
  }
}

Note

Store the id (uwResultId), revision, and debt IDs from the response - you’ll need them for updates and offer generation.

Response Summary

The response includes:

• applicationUwResult: Overall eligibility summary
  • applicantPrequalified: Whether the applicant qualifies
  • totalDebt: Total debt found on credit report
  • totalEligibleDebt: Sum of eligible debts
• applicantUwResult.debts: Individual debt eligibility
  • eligibilityStatus: ELIGIBLE, INELIGIBLE, or CONDITIONAL

Step 4: Update Applicant Eligibility (Optional)

If you need to modify applicant information or debt selections, use the update mutation.

mutation UpdateApplicantEligibility(
  $applicationType: ApplicationTypeInput!
  $input: UwResultUpdateInput!
) {
  updateApplicantEligibility(applicationType: $applicationType, input: $input) {
    data {
      id
      revision
      applicationUwResult {
        applicantPrequalified
        totalEligibleDebt
      }
    }
    errors {
      message
    }
  }
}

Variables (updating debt selection):

{
  "applicationType": "SINGLE",
  "input": {
    "uwResultId": "{{uwResultId}}",
    "revision": 1,
    "updatedBy": "api-user",
    "debts": [
      {
        "id": "{{debtId}}",
        "isSelected": true
      }
    ]
  }
}

Step 5: Generate Offers

Use the Offer Generation API to create payment plan options. This step allows you to calculate various payment options based on deposit frequency, deposit intervals, and payment term.

Endpoint: https://debt-core-api-sandbox.alleviate.com/og-service/graphql

mutation Offers($input: OffersInput!) {
  offers(input: $input) {
    data {
      compTemplateId
      frequency
      frequencyInterval
      firstPaymentDate
      paymentTerm
      maxPaymentTerm
      enrolledDebt
      enrollmentPlanId
      enrollmentPlanName
      serviceFee
      estimatedSettlementFee
      totals {
        fee1
        fee2
        savings
        totalPayment
      }
      payments {
        paymentDate
        paymentNumber
        totalPayment
      }
    }
    errors {
      message
    }
  }
}

Variables:

{
  "input": {
    "firstPaymentDate": "2025/12/12",
    "uwResultId": "{{uwResultId}}",
    "revision": 1,
    "depositFrequency": null,
    "depositIntervals": null,
    "paymentTerm": null,
    "includeSentryFee": null
  }
}

Note

Review the payment plans returned and select the one that best fits your customer’s needs. You’ll use the same input parameters in the next step to create the offer.

Step 6: Create Offer

After selecting a payment plan, use createOffer to save the selected plan. This converts the transient plan into a persistent offer and returns an offerId (also referred to as ogId) that you’ll use for enrollment.

Endpoint: https://debt-core-api-sandbox.alleviate.com/og-service/graphql

mutation CreateOffer($input: OffersInput!) {
  createOffer(input: $input) {
    data {
      id
      uwResultId
      uwResultRevision
      frequency
      frequencyInterval
      firstPaymentDate
      paymentTerm
      maxPaymentTerm
      enrolledDebt
      enrollmentPlanId
      enrollmentPlanName
      serviceFee
      estimatedSettlementFee
      totals {
        fee1
        fee2
        fee3
        fee4
        fee5
        fee6
        fee7
        savings
        totalPayment
      }
      payments {
        fee1
        fee2
        fee3
        fee4
        fee5
        fee6
        fee7
        paymentDate
        paymentNumber
        savings
        totalPayment
      }
      forthRequestParameters {
        epFee1Amount
        fee2Amount
        fee2Ends
        epFee2Monthly
        epFee3Amount
        epFee3Monthly
        epFee4Monthly
        epFee4Amount
        epFee5Monthly
        epFee5Amount
        firstPaymentDate
        recurringStartDate
        epFrequency
        epFreqInterval
        debt
        enrollmentPlan
        maxPaymentTerm
        estSettlement
      }
      compTemplateId
    }
    errors {
      message
    }
  }
}

Variables:

{
  "input": {
    "firstPaymentDate": "2025/04/12",
    "depositFrequency": "M",
    "depositIntervals": "12",
    "uwResultId": "{{uwResultId}}",
    "revision": 1,
    "includeSentryFee": true,
    "paymentTerm": "60"
  }
}

Note

Store the id (offerId/ogId) from the response - you’ll need it to create the enrollment in the next step.

Step 7: Create Enrollment

After creating an offer, use createEnrollment to create the client file in the destination CRM.

Endpoint: https://debt-core-api-sandbox.alleviate.com/enrollment-service/graphql

mutation CreateEnrollment($input: CreateEnrollmentInput!) {
  createEnrollment(input: $input) {
    data {
      enrollmentId
    }
    errors {
      message
    }
  }
}

Variables:

{
  "input": {
    "ogId": "{{offerId}}",
    "leadId": "11223344",
    "contact": {
      "language": "1",
      "budgetFields": [
        {
          "fieldId": "monthlyIncome",
          "value": "5000.00"
        },
        {
          "fieldId": "monthlyExpenses",
          "value": "3500.00"
        }
      ],
      "customFields": [
        {
          "fieldId": "referralSource",
          "value": "Website"
        }
      ],
      "notes": [
        {
          "content": "Client prefers communication via email"
        }
      ]
    }
  }
}

Note

• ogId: The offer ID from the createOffer response
• leadId: Your internal lead/contact ID
• contact: Optional — applicant PII (name, SSN, address, etc.) is sourced from UW data
• language: "1" for English, "2" for Spanish
• budgetFields: Optional income/expense data as field ID-value pairs
• customFields: Optional additional data as field ID-value pairs
• notes: Optional notes to attach to the contact
• Store the enrollmentId from the response - you’ll use it to check enrollment status

Step 8: Check Enrollment Status

Use the enrollmentStatus query to monitor the progress of enrollment creation. After calling createEnrollment, it returns an enrollmentId that you can use to track the status of individual enrollment steps.

Endpoint: https://debt-core-api-sandbox.alleviate.com/enrollment-service/graphql

query EnrollmentStatus($enrollmentId: String!) {
  enrollmentStatus(enrollmentId: $enrollmentId) {
    data {
      qaCall
      createContact
      createNotes
      createDebts
      createBudget
      createBankAccount
      createDocuments
    }
    errors {
      message
    }
  }
}

Variables:

{
  "enrollmentId": "{{enrollmentId}}"
}

Status Values

Each step in the response will have one of the following statuses:

• PENDING - Step has not started yet
• IN_PROGRESS - Step is currently being processed
• COMPLETED - Step finished successfully
• FAILED - Step encountered an error

Tip

Poll this endpoint periodically to track enrollment progress. The enrollment process runs asynchronously in the background, so you may need to check multiple times until all steps show COMPLETED.

Complete Flow Diagram

┌──────────────────────────────────────────────────────────────────────────────┐
│                         Single Applicant Enrollment Flow                      │
├──────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  1. Authenticate (Azure AD)                                                  │
│     └─► Returns: access_token                                                │
│              │                                                               │
│              ▼                                                               │
│  2. pullCreditReport (Credit API)                                            │
│     └─► Returns: creditReportId                                              │
│              │                                                               │
│              ▼                                                               │
│  3. checkApplicantEligibility (Underwriting API)                             │
│     └─► Returns: uwResultId, revision, debts[]                               │
│              │                                                               │
│              ▼                                                               │
│  4. updateApplicantEligibility [OPTIONAL] (Underwriting API)                 │
│     └─► Returns: updated uwResultId, revision                                │
│              │                                                               │
│              ▼                                                               │
│  5. offers (Offer Generation API)                                            │
│     └─► Returns: payment plans, totals, schedule                             │
│              │                                                               │
│              ▼                                                               │
│  6. createOffer (Offer Generation API)                                       │
│     └─► Returns: offerId (ogId)                                             │
│              │                                                               │
│              ▼                                                               │
│  7. createEnrollment (Enrollment API)                                        │
│     └─► Returns: enrollmentId                                                │
│              │                                                               │
│              ▼                                                               │
│  8. enrollmentStatus (Enrollment API)                                        │
│     └─► Returns: status of enrollment steps                                  │
│                                                                              │
└──────────────────────────────────────────────────────────────────────────────┘

API Endpoints

API	Sandbox URL
Credit API	https://debt-core-api-sandbox.alleviate.com/credit-service/graphql
Underwriting API	https://debt-core-api-sandbox.alleviate.com/underwriting-service/graphql
Offer Generation API	https://debt-core-api-sandbox.alleviate.com/og-service/graphql
Enrollment API	https://debt-core-api-sandbox.alleviate.com/enrollment-service/graphql

Best Practices

1. Validate at each step - Check for errors in the response before proceeding
2. Store intermediate IDs - Keep track of creditReportId, uwResultId, revision, offerId and enrollmentId
3. Handle eligibility status - Some debts may be CONDITIONAL and require additional info
4. Monitor enrollment progress - Poll enrollmentStatus until all steps show COMPLETED
5. Use the Postman collection - Test scripts automatically extract and save IDs between requests

Tip

Download the Postman Collection to run this flow with pre-configured test data.