Workday APIdeveloper.workday.com ↗

"""
Workday Developer Documentation API Client
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Any, Dict, List, Optional


class ParseClient:
    """Client for interacting with the Workday Developer Documentation API."""

    def __init__(self, api_key: Optional[str] = None):
        """Initialize the Parse API client.
        
        Args:
            api_key: API key for authentication. If not provided, uses PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "b2cd46f9-4aac-4f96-9594-256329e52c1b"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError("API key must be provided or set in PARSE_API_KEY environment variable")

    def _call(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
        """Make an API call to the Parse bot scraper.
        
        Args:
            endpoint: The API endpoint name
            method: HTTP method (GET or POST)
            **params: Query/body parameters
            
        Returns:
            Response JSON as dictionary
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        
        if method == "GET":
            response = requests.get(url, headers=headers, params=params)
        elif method == "POST":
            response = requests.post(url, headers=headers, json=params)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")
        
        response.raise_for_status()
        return response.json()

    def get_documentation_tree(self) -> Dict[str, Any]:
        """Get the complete documentation navigation tree.
        
        Returns the full flat list of all documentation pages with their titles, URLs, and slugs.
        
        Returns:
            Dictionary containing total count and list of page objects
        """
        return self._call("get_documentation_tree", method="GET")

    def get_doc_page(self, slug: str) -> Dict[str, Any]:
        """Get a specific documentation page by its slug.
        
        Args:
            slug: The page identifier slug
            
        Returns:
            Dictionary containing page title, metadata, and Markdown content
        """
        return self._call("get_doc_page", method="GET", slug=slug)

    def search_documentation(self, query: str, limit: int = 20) -> Dict[str, Any]:
        """Search the documentation for pages matching the query.
        
        Args:
            query: Search term to match against page titles (case-insensitive)
            limit: Maximum number of results to return (default: 20)
            
        Returns:
            Dictionary containing search results with matching pages
        """
        return self._call("search_documentation", method="GET", query=query, limit=limit)

    def get_doc_home(self) -> Dict[str, Any]:
        """Get the documentation homepage configuration.
        
        Returns curated sections, link groups, and recommended pages.
        
        Returns:
            Dictionary containing homepage sections with links and groups
        """
        return self._call("get_doc_home", method="GET")


def main():
    """Practical workflow example using the Workday Developer Documentation API."""
    
    client = ParseClient()
    
    print("=" * 80)
    print("WORKDAY DEVELOPER DOCUMENTATION API - PRACTICAL EXAMPLE")
    print("=" * 80)
    
    print("\n1. Getting homepage sections to understand the documentation structure...")
    homepage = client.get_doc_home()
    print(f"   Found {len(homepage['sections'])} main sections:")
    for section in homepage['sections']:
        print(f"   - {section['title']}: {section['description'][:60]}...")
    
    print("\n2. Searching for 'REST API' documentation...")
    search_results = client.search_documentation("REST API", limit=5)
    print(f"   Found {search_results['total_results']} pages matching 'REST API'")
    
    if search_results['results']:
        print("   Top results:")
        for i, result in enumerate(search_results['results'][:3], 1):
            print(f"   {i}. {result['title']}")
            print(f"      Slug: {result['slug']}")
    
    print("\n3. Getting detailed content from the first search result...")
    if search_results['results']:
        first_result = search_results['results'][0]
        slug = first_result['slug']
        
        print(f"   Fetching full content for: {first_result['title']}")
        page_content = client.get_doc_page(slug)
        
        print(f"   Title: {page_content['title']}")
        print(f"   Categories: {', '.join(page_content['category'][:2])}...")
        print(f"   Keywords: {', '.join(page_content['keywords'][:3])}...")
        print(f"   Content preview (first 300 chars):")
        print(f"   {page_content['content'][:300]}...")
    
    print("\n4. Searching for 'Integration' to find integration-related docs...")
    integration_results = client.search_documentation("Integration", limit=3)
    print(f"   Found {integration_results['total_results']} pages with 'Integration'")
    
    print("\n5. Fetching details for all integration results...")
    for result in integration_results['results'][:3]:
        print(f"\n   Getting: {result['title']}")
        page_data = client.get_doc_page(result['slug'])
        
        content_preview = page_data['content'][:200].replace('\n', ' ')
        print(f"   Preview: {content_preview}...")
        print(f"   Categories: {page_data['category'][0] if page_data['category'] else 'N/A'}")
    
    print("\n6. Getting glossary page to understand Workday terminology...")
    glossary_results = client.search_documentation("Glossary", limit=1)
    if glossary_results['results']:
        glossary_slug = glossary_results['results'][0]['slug']
        glossary_page = client.get_doc_page(glossary_slug)
        print(f"   Found glossary: {glossary_page['title']}")
        print(f"   Content preview (first 500 chars):")
        print(f"   {glossary_page['content'][:500]}")
    
    print("\n" + "=" * 80)
    print("WORKFLOW COMPLETE - Successfully demonstrated API functionality")
    print("=" * 80)


if __name__ == "__main__":
    main()