Step by Step Guide to Building a Teachable API Integration in PHP

Aug 11, 2024 • 7 minute read

Hey there, fellow developer! Ready to dive into the world of Teachable API integration? Let's roll up our sleeves and get our hands dirty with some PHP code. This guide will walk you through the process of building a robust Teachable API integration, assuming you're already familiar with PHP and API concepts. Let's get started!

Introduction

Teachable's API is a powerful tool that allows you to interact with their platform programmatically. Whether you're looking to automate course management, sync user data, or build custom reporting tools, this integration will set you on the right path.

Prerequisites

Before we jump in, make sure you've got:

A PHP environment set up (PHP 7.4+ recommended)
A Teachable account with API access
Composer installed for managing dependencies

We'll be using Guzzle for HTTP requests, so let's install it:

composer require guzzlehttp/guzzle

Authentication

First things first, let's get authenticated. Head over to your Teachable admin panel and grab your API key. We'll use this to set up our authentication headers:

$apiKey = 'your_api_key_here';
$headers = [
    'Authorization' => 'Bearer ' . $apiKey,
    'Accept' => 'application/json'
];

Basic API Request Structure

Now, let's create a simple function to make API requests:

use GuzzleHttp\Client;

function makeApiRequest($method, $endpoint, $data = []) {
    $client = new Client(['base_uri' => 'https://api.teachable.com/v1/']);
    $response = $client->request($method, $endpoint, [
        'headers' => $GLOBALS['headers'],
        'json' => $data
    ]);
    return json_decode($response->getBody(), true);
}

Implementing Core Functionalities

Let's implement some core functionalities:

Fetching Courses

function getCourses() {
    return makeApiRequest('GET', 'courses');
}

Creating Users

function createUser($userData) {
    return makeApiRequest('POST', 'users', $userData);
}

Enrolling Users in Courses

function enrollUserInCourse($userId, $courseId) {
    return makeApiRequest('POST', "enrollments", [
        'user_id' => $userId,
        'course_id' => $courseId
    ]);
}

Error Handling and Rate Limiting

Always handle those pesky errors and respect rate limits:

function makeApiRequest($method, $endpoint, $data = []) {
    try {
        $response = $client->request($method, $endpoint, [
            'headers' => $GLOBALS['headers'],
            'json' => $data
        ]);
        
        $remainingRequests = $response->getHeader('X-RateLimit-Remaining')[0] ?? null;
        if ($remainingRequests !== null && $remainingRequests < 10) {
            // Consider implementing a backoff strategy here
        }
        
        return json_decode($response->getBody(), true);
    } catch (RequestException $e) {
        // Handle the error appropriately
        error_log($e->getMessage());
        return null;
    }
}

Data Processing and Storage

Once you've got your data, don't forget to process and store it:

$courses = getCourses();
foreach ($courses as $course) {
    // Store or update course in your database
    storeCourseInDatabase($course);
}

Webhooks Integration

Teachable supports webhooks for real-time updates. Set up an endpoint in your application to receive these:

function handleWebhook() {
    $payload = json_decode(file_get_contents('php://input'), true);
    $event = $payload['event'];
    
    switch ($event) {
        case 'user.created':
            // Handle new user
            break;
        case 'enrollment.created':
            // Handle new enrollment
            break;
        // Add more cases as needed
    }
}

Testing and Debugging

Always test your integration thoroughly. Here's a simple test function:

function testApiConnection() {
    $response = getCourses();
    if ($response) {
        echo "API connection successful!";
    } else {
        echo "API connection failed.";
    }
}

Best Practices and Optimization

Remember to implement caching for frequently accessed data and consider using asynchronous requests for better performance:

use GuzzleHttp\Pool;
use GuzzleHttp\Psr7\Request;

$client = new Client();
$requests = function ($total) {
    $uri = 'https://api.teachable.com/v1/courses';
    for ($i = 0; $i < $total; $i++) {
        yield new Request('GET', $uri);
    }
};

$pool = new Pool($client, $requests(100), [
    'concurrency' => 5,
    'fulfilled' => function ($response, $index) {
        // Handle successful response
    },
    'rejected' => function ($reason, $index) {
        // Handle failed request
    },
]);

$promise = $pool->promise();
$promise->wait();

Conclusion

And there you have it! You've now got a solid foundation for your Teachable API integration. Remember, this is just the beginning. There's so much more you can do with the API, so don't be afraid to explore and experiment.

Additional Resources

Happy coding, and may your integration be bug-free and performant!