Forsta (Decipher)

Single Followup Question

To add a single followup question for an open-end, follow these steps: First, initialize the API request data in an <exec> block. This sets up the headers and prepares the request body:

<exec>
# Set up API headers with your Aftercare API key
p.api_headers = {
    "X-Aftercare-Key": "<AFTERCARE API KEY>",
    "Content-Type": "application/json"
}

# Get the question and response from your survey
question = TopicQuestion.title  # replace with your topic question variable
response = TopicQuestion.val  # replace with your topic question variable

# Prepare the API request body
p.api_data = '{
    "question": "' + question + '",
    "answer": "' + response + '",
    "surveyName": "<Your Survey Name>",  # optional
    "surveyDescription": "<Description of your survey>",  # optional
    "questionContext": "<What you want to learn from the respondent>",  # optional
    "guidanceBehavior": "Succinct"  # optional, defaults to "Succinct"
}'
</exec>

Next, make the API request using the <logic> block. This sends the request to Aftercare’s API and waits for the response:

<logic
    label="followup_request"
    api:data="p.api_data"
    api:headers="p.api_headers"
    api:method="POST"
    api:url="https://surveys.getaftercare.com/api/v1/followups"
    sst="0"
    uses="api.1"
/>

After receiving the response, process it in another <exec> block. This handles both successful responses and errors:

<exec>
# Check if the API call was successful
if followup_request.status == 200:
    # Extract the followup question from the response
    p.followup_question = followup_request.r["followupQuestion"]
else:
    # Use a fallback question if the API call fails
    p.followup_question = "Is there anything more you'd like to add?"
</exec>

Now, display the followup question to the respondent using a <textarea> element:

<suspend />
<textarea
    label="FollowupQuestion"
    height="10"
    optional="0"
    width="50">
    <title>${p.followup_question}</title>
</textarea>

Finally, store the followup question in a variable for data export and reporting:

<suspend />
<exec>FOLLOWUP_Q_TEXT.val = p.followup_question</exec>
<suspend />
<text
    label="FOLLOWUP_Q_TEXT"
    optional="0"
    size="25"
    where="execute,survey,report">
    <title>FOLLOWUP_Q_TEXT</title>
</text>
<suspend />

Multiple Followup Questions

To implement multiple followup questions that continue until the AI determines no more questions are needed, follow these steps: First, initialize the API request data and tracking variables. This sets up the headers and prepares the variables we’ll need to track multiple followups:

<exec>
# Set up API headers with your Aftercare API key
p.api_headers = {
    "X-Aftercare-Key": "<AFTERCARE API KEY>",
    "Content-Type": "application/json"
}

# Get the initial question and response
p.question = TopicQuestion.title  # replace with your topic question variable
p.initial_response = TopicQuestion.val  # replace with your topic question variable

# Initialize tracking variables
p.max_followups = 10  # replace with number of maximum desired follwups for one question
p.current_followup = 1
p.total_followups_shown = 0

# Create arrays to store all followup questions and responses
p.followup_questions = []
p.followup_responses = []

# Initialize thread ID variable
p.thread_id = None
</exec>

Next, set up the loop structure that will handle multiple followups. This includes the loop label and the initial check for maximum followups:

# --- START THE FOLLOWUP LOOP ---

<label name="GENERATE_FOLLOWUP" />

# Check if we've reached the maximum number of followups
<exec>
p.continue_followup = p.current_followup <= p.max_followups
</exec>

<goto condition="!p.continue_followup" label="END_FOLLOWUPS" />

Now, prepare the API request. For the first followup, we use the initial question and response. For subsequent followups, we use the previous followup question and response:

<exec>
if p.current_followup == 1:
    # First followup uses initial question and response
    p.prev_question = p.question
    p.prev_response = p.initial_response
    # First followup doesn't need a thread ID
    p.api_data = '{
        "question": "' + p.prev_question + '",
        "answer": "' + p.prev_response + '",
        "surveyName": "<Your Survey Name>",  # optional
        "surveyDescription": "<Description of your survey>",  # optional
        "questionContext": "<What you want to learn from the respondent>",  # optional
        "guidanceBehavior": "Succinct"  # optional, defaults to "Succinct"
    }'
else:
    # Subsequent followups use the previous followup question and response
    p.prev_question = p.followup_questions[p.current_followup - 2]  # Arrays are 0-indexed
    p.prev_response = p.followup_responses[p.current_followup - 2]
    # Include thread ID for followups after the first one
    p.api_data = '{
        "question": "' + p.prev_question + '",
        "answer": "' + p.prev_response + '",
        "surveyName": "<Your Survey Name>",  # optional
        "surveyDescription": "<Description of your survey>",  # optional
        "questionContext": "<What you want to learn from the respondent>",  # optional
        "guidanceBehavior": "Succinct",  # optional, defaults to "Succinct"
        "threadId": "' + p.thread_id + '"  # required for followups after the first one
    }'
</exec>

Make the API call to get the followup question:

<logic
    label="followup_request"
    api:data="p.api_data"
    api:headers="p.api_headers"
    api:method="POST"
    api:url="https://surveys.getaftercare.com/api/v1/followups"
    sst="0"
    uses="api.1"
/>

Process the API response and check if we should continue with followups:

<exec>
# Check if the API call was successful
if followup_request.status == 200:
    # Extract the followup question from the response
    p.current_followup_text = followup_request.r["followupQuestion"]

    # For the first followup, store the thread ID for subsequent followups
    if p.current_followup == 1:
        p.thread_id = followup_request.r["threadId"]
else:
    # Use a fallback question if the API call fails
    p.current_followup_text = ""

# Check if the followup text is blank, which means we should stop
p.is_blank_followup = p.current_followup_text.strip() == ""

# Store the current followup text in a variable that matches the current followup number
set("FOLLOWUP_TEXT_" + str(p.current_followup), p.current_followup_text)
</exec>

# Skip to the end if we got a blank followup
<goto condition="p.is_blank_followup" label="END_FOLLOWUPS" />

Display the followup question to the respondent and get their response:

<textarea
    label="FollowupQuestion_${p.current_followup}"
    height="10"
    optional="1"
    width="50"
>
    <title>${p.current_followup_text}</title>
</textarea>

<suspend />

<exec>
# Get the response
p.current_response = eval("FollowupQuestion_" + str(p.current_followup) + ".unsafe_val")

# Check if response is blank
p.is_blank_response = p.current_response.strip() == ""

# Store the followup question and response in our arrays
p.followup_questions.append(p.current_followup_text)
p.followup_responses.append(p.current_response)

# Increment the followup counter and total followups shown
p.total_followups_shown = p.current_followup
p.current_followup += 1

# Store the response in a variable
set("FOLLOWUP_RESPONSE_" + str(p.total_followups_shown), p.current_response)
</exec>

Check if we should continue with more followups:

# If the response was blank, end the followups
<goto condition="p.is_blank_response" label="END_FOLLOWUPS" />

# Otherwise, continue with the next followup
<goto label="GENERATE_FOLLOWUP" />

Finally, set up the end of the followup section and store all responses for reporting:

# --- END OF FOLLOWUPS ---

<label name="END_FOLLOWUPS" />

# Store the total number of followups shown
<exec>TOTAL_FOLLOWUPS.val = p.total_followups_shown</exec>

<text
    label="TOTAL_FOLLOWUPS"
    optional="0"
    size="5"
    where="execute,survey,report"
>
    <title>Total number of followups shown</title>
</text>

<exec>
# Store responses in their respective variables
for i in range(p.total_followups_shown):
    set("FOLLOWUP_RESPONSE_" + str(i + 1), p.followup_responses[i])
</exec>

Data Quality Evaluation

To evaluate the quality of responses using Aftercare’s Data Quality API, follow these steps: First, initialize the API request data in an <exec> block. This sets up the headers and prepares the request body:

<exec>
# Set up API headers with your Aftercare API key
p.api_headers = {
    "X-Aftercare-Key": "<AFTERCARE API KEY>",
    "Content-Type": "application/json"
}

# Get the questions and responses from your survey. You can evaluate multiple answers from the respondent at once
p.survey_entries = []
p.survey_entries.append({
    "question": TopicQuestion1.title,  # The question that was asked to the respondent
    "answer": TopicQuestion1.val,      # The answer to the question provided by the respondent
    "questionIdentifier": "q1",        # Optional unique identifier for the question
})
p.survey_entries.append({
    "question": TopicQuestion2.title,
    "answer": TopicQuestion2.val,
    "questionIdentifier": "q2",
})

# Prepare the API request body
p.api_data = '{
    "surveyName": "<Your Survey Name>",  # The name of the survey as it will appear in the Aftercare platform
    "surveyDescription": "<Description of your survey>",  # Description of the survey purpose and background
    "surveyIdentifier": "survey_123",  # Optional unique identifier for the survey
    "responseIdentifier": "resp_123",  # Optional unique identifier for a respondent's entire response
    "surveyEntries": [
        {
            "question": "' + p.survey_entries[0]["question"] + '",
            "answer": "' + p.survey_entries[0]["answer"] + '",
            "questionIdentifier": "' + p.survey_entries[0]["questionIdentifier"] + '",
        },
        {
            "question": "' + p.survey_entries[1]["question"] + '",
            "answer": "' + p.survey_entries[1]["answer"] + '",
            "questionIdentifier": "' + p.survey_entries[1]["questionIdentifier"] + '",
        }
    ]
}'
</exec>

Next, make the API request using the <logic> block. This sends the request to Aftercare’s Data Quality API and waits for the response:

<logic
    label="quality_request"
    api:data="p.api_data"
    api:headers="p.api_headers"
    api:method="POST"
    api:url="https://surveys.getaftercare.com/api/v1/data-quality"
    sst="0"
    uses="api.1"
/>

After receiving the response, process it in another <exec> block. This handles both successful responses and errors:

<exec>
# Check if the API call was successful
if quality_request.status == 200:
    # Extract the overall quality metrics
    p.has_issues = quality_request.r["hasIssues"]  # Whether any issues were detected
    p.num_issues = quality_request.r["numIssues"]  # Number of quality issues detected across all entries
    p.quality_score = quality_request.r["qualityScore"]  # Overall quality score (0-100)

    # Process individual evaluations
    p.evaluations = quality_request.r["evaluations"]
    for i, evaluation in enumerate(p.evaluations):
        # Each evaluation contains:
        # - surveyEntry: The original question and answer
        # - numIssues: Number of issues detected for this entry
        # - qualityScore: Quality score for this entry (0-100)
        # - qualityIssueChecks: Detailed quality checks
        # - hasIssues: Whether any issues were detected

        # Store the quality score for this entry
        set("QUALITY_SCORE_" + str(i + 1), evaluation["qualityScore"])

        # Store the number of issues for this entry
        set("NUM_ISSUES_" + str(i + 1), evaluation["numIssues"])

        # Store whether issues were detected
        set("HAS_ISSUES_" + str(i + 1), evaluation["hasIssues"])
</exec>

You can then either:

Store these values in your survey data for analysis
Access the Aftercare platform to view and download the quality evaluations

Need help? Contact our support team

Get Started

Core Products

Single Followup Question

Multiple Followup Questions

Data Quality Evaluation

​Single Followup Question

​Multiple Followup Questions

​Data Quality Evaluation

Single Followup Question

Multiple Followup Questions

Data Quality Evaluation