Skip to main content

​
What are Zapier Searches?

Zapier searches allow you to find and retrieve specific data from your Opigno Enterprise LIP. They’re used to look up existing records, validate data, or find information needed for your automation workflows.
Searches are essential for preventing duplicate data, validating user information, and retrieving context needed for other actions in your Zaps.

​
Available Searches

The Opigno Enterprise Zapier integration provides 2 searches that allow you to retrieve specific training progress information from your learning management system. All searches use GraphQL queries to fetch data and provide structured results for automation workflows.

​
Training Progress Searches

​
Get Score of User for Training

Search Key: get_score_of_user_for_training_search
Description: Retrieves the score achieved by a user for a specific training/learning path.
This search uses the learningPath query which fetches:
  • Learning Path Data: Training ID and training details
  • Attempt Metrics: User’s attempt data including global score
  • Training Information: Complete training metadata
  • client_uuid (string, required): The UUID of the user whose score you want to retrieve
  • training_id (string, required): The ID of the training/learning path to get the score for
  • id (integer): Training ID that was queried
  • score (integer): The user’s global score for the training (0 if no score available)
  • Progress Tracking: Monitor user performance on specific trainings
  • Performance Analytics: Generate reports on training effectiveness
  • Conditional Logic: Trigger different actions based on score thresholds
  • Compliance Monitoring: Track completion scores for mandatory training

​
Get Status of User for Training

Search Key: get_status_of_user_for_training_search
Description: Retrieves the current status of a user’s progress on a specific training/learning path.
This search uses the learningPath query which fetches:
  • Learning Path Data: Training ID and training details
  • Attempt Metrics: User’s attempt data including completion status
  • Training Information: Complete training metadata
  • client_uuid (string, required): The UUID of the user whose status you want to retrieve
  • training_id (string, required): The ID of the training/learning path to get the status for
  • id (integer): Training ID that was queried
  • status (string): The user’s current status for the training (e.g., ‘COMPLETED’, ‘NOT_STARTED’, ‘IN_PROGRESS’)
  • Progress Monitoring: Check if users have started or completed training
  • Workflow Automation: Trigger different actions based on completion status
  • Compliance Reporting: Track mandatory training completion status
  • User Management: Identify users who need to complete specific training

​
Setting Up Searches

All Opigno Enterprise searches use GraphQL queries to retrieve specific training progress data. Each search requires specific input parameters and returns structured data for automation workflows.
1

Choose Your Search Type

  1. In Zapier, select Opigno Enterprise as your search app
  2. Choose from the 2 available searches based on your data needs:
    • Get Score of User for Training: Retrieve user’s score for a specific training
    • Get Status of User for Training: Retrieve user’s completion status for a specific training
  3. Review the search description and data structure
2

Configure Authentication

  1. Connect your Opigno Enterprise account using your API credentials
  2. Ensure your API user has appropriate permissions to access training progress data
  3. Test the connection to verify authentication works correctly
3

Set Up Search Parameters

Both searches require the same input parameters:Required Parameters:
  • client_uuid (string): The UUID of the user whose data you want to retrieve
  • training_id (string): The ID of the training/learning path to query
Parameter Mapping:
  • Map data from previous Zap steps to these required parameters
  • Ensure the client_uuid corresponds to a valid user in your Opigno instance
  • Verify the training_id exists and is accessible to the user
4

Handle Search Results

  1. Both searches return structured data with training ID and either score or status
  2. Set up conditional logic based on the returned values:
    • Score Search: Use score values for performance-based automation
    • Status Search: Use status values for completion-based workflows
  3. Configure fallback actions for cases where no data is found
  4. Map search results to subsequent Zap steps
5

Test Your Search

  1. Use Zapier’s test feature with valid user UUIDs and training IDs
  2. Verify that results match your expectations
  3. Test with different users and trainings to ensure reliability
  4. Check error handling for invalid parameters

​
Search Patterns and Best Practices

​
Conditional Logic with Searches

Use the available searches to implement conditional logic in your Zaps: 
// Search for user's training score
const scoreResult = await searchUserScore(client_uuid, training_id);

if (scoreResult.score >= 80) {
  // High score - send congratulations
  await sendCongratulationEmail(user);
} else if (scoreResult.score >= 60) {
  // Passing score - send completion certificate
  await generateCertificate(user, training);
} else {
  // Low score - trigger retraining
  await assignRetraining(user, training);
}

​
Data Validation Patterns

Use searches to validate training progress before performing actions:
Pre-Action Validation: Always search for existing training progress before creating new assignments or sending notifications to avoid duplicate actions.
Parameter Validation: Ensure client_uuid and training_id are valid before making search requests to avoid GraphQL errors.

​
Error Handling for Searches

Common Scenarios:
  • User hasn’t started the training (score = 0, status = ‘NOT_STARTED’)
  • Training doesn’t exist or user doesn’t have access
  • Invalid client_uuid or training_id parameters
Handling Strategies:
  • Check for default values (score = 0, status = ‘NOT_STARTED’)
  • Set up conditional paths for different scenarios
  • Provide fallback actions for missing data
  • Log search failures for debugging
Common Scenarios:
  • Invalid training_id parameter
  • User doesn’t have permission to access training data
  • Opigno instance configuration issues
  • Network connectivity problems
Handling Strategies:
  • Validate all input parameters before making requests
  • Ensure API user has appropriate permissions
  • Test GraphQL queries directly against Opigno API
  • Implement proper retry logic for transient failures

​
Performance Optimization

​
Search Efficiency

  • Parameter Validation: Always validate client_uuid and training_id before making requests
  • Error Handling: Implement proper error handling for GraphQL query failures
  • Result Processing: Handle default values appropriately (score = 0, status = ‘NOT_STARTED’)
  • Conditional Logic: Use search results to drive conditional workflows efficiently

​
API Usage Management

  • GraphQL Queries: Both searches use the same learningPath query with different response mapping
  • Error Handling: Searches throw descriptive errors when GraphQL queries fail
  • Parameter Mapping: Ensure proper mapping of input parameters to GraphQL variables
  • Result Validation: Validate search results before using them in subsequent steps

​
Troubleshooting Searches

Common causes:
  • Invalid client_uuid parameter (user doesn’t exist)
  • Invalid training_id parameter (training doesn’t exist)
  • User doesn’t have access to the specified training
  • Training hasn’t been started (returns default values)
Solutions:
  • Verify client_uuid corresponds to a valid user in Opigno
  • Check that training_id exists and is accessible
  • Ensure user has proper permissions for the training
  • Handle default values appropriately (score = 0, status = ‘NOT_STARTED’)
Common causes:
  • Invalid training_id format or value
  • Insufficient API permissions
  • Opigno instance configuration issues
  • Network connectivity problems
Solutions:
  • Validate training_id format before making requests
  • Ensure API user has appropriate permissions
  • Test GraphQL queries directly against Opigno API
  • Check Opigno instance logs for detailed error messages
  • Implement proper retry logic for transient failures
Common scenarios:
  • Score returns 0 when user hasn’t started training
  • Status returns ‘NOT_STARTED’ for new assignments
  • Training ID doesn’t match expected training
Solutions:
  • Check for default values in search results
  • Verify training_id mapping is correct
  • Implement conditional logic for different result scenarios
  • Log search parameters and results for debugging

​
Next Steps

Continue building your automation workflows:

Zapier Triggers

Learn how to set up automated triggers for your workflows.

Zapier Actions

Discover how to configure actions that respond to your triggers.
⌘I