SDKs and Libraries in Developer Portals

SDKs and libraries simplify API integration by providing language-specific wrappers. Learn how to create, document, and maintain SDKs for multiple programming languages in your developer portal.

What You'll Learn

You will learn how to create SDKs for your API, how to document them effectively, and how to maintain them across programming languages.

Why It Matters

SDKs dramatically reduce integration time. Developers prefer using a well-designed SDK over making raw HTTP calls. Poor SDKs or missing language support is a common reason developers abandon an API.

Real-World Use

Durga Antivirus Pro provides SDKs for Python, JavaScript, Go, and Java. Each SDK wraps the REST API with idiomatic methods, type hints, and error handling. The Python SDK is the most popular.

flowchart LR
  A[API] --> B[Python SDK]
  A --> C[JavaScript SDK]
  A --> D[Go SDK]
  A --> E[Java SDK]
  B --> F[Install via pip]
  C --> G[Install via npm]
  D --> H[Install via go get]
  A:::current
  classDef current fill:#f90,color:#fff,stroke:#333,stroke-width:2px

SDK Documentation Structure

# Python SDK for Threat Intelligence API

## Installation

```bash
pip install durga-threat-intel

Quickstart

from durga_threat_intel import ThreatClient

client = ThreatClient(api_key="dga_your_api_key_here")
threats = client.list_threats(limit=5, severity="critical")
print(threats)

Reference

ThreatClient

class ThreatClient:
    def __init__(self, api_key: str, base_url: str = None):
        """Initialize the threat intelligence client."""

    def list_threats(self, limit: int = 20, severity: str = None):
        """List recent threats matching optional filters."""

    def get_threat(self, threat_id: str):
        """Get detailed information about a specific threat."""

    def submit_sample(self, file_path: str):
        """Submit a file sample for analysis."""

Error Handling

from durga_threat_intel import ThreatClient, ThreatAPIError

client = ThreatClient(api_key="invalid_key")
try:
    threats = client.list_threats()
except ThreatAPIError as e:
    print(f"API Error {e.status_code}: {e.message}")
    # Handle: 401 - Invalid API key, 429 - Rate limited, etc.

## SDK Generation

```bash
# Generate SDK from OpenAPI spec using OpenAPI Generator
pip install openapi-generator
npx @openapitools/openapi-generator-cli generate \
  -i openapi.yaml \
  -g python \
  -o sdks/python/

# For JavaScript
npx @openapitools/openapi-generator-cli generate \
  -i openapi.yaml \
  -g javascript \
  -o sdks/javascript/

SDK Testing

# test_sdk.py
import pytest
from durga_threat_intel import ThreatClient

def test_list_threats():
    client = ThreatClient(api_key="test_key")
    threats = client.list_threats(limit=1)
    assert len(threats.data) > 0
    assert threats.data[0].id.startswith("thr_")

def test_invalid_api_key():
    client = ThreatClient(api_key="invalid")
    with pytest.raises(Exception, match="401"):
        client.list_threats()

Common Mistakes

1. Not Auto-Generating SDKs

Manually maintained SDKs drift from the API specification. Generate SDKs from the OpenAPI spec automatically.

2. Inconsistent Naming Across Languages

The Python SDK calls it list_threats while the JavaScript SDK calls it getThreats. Use consistent naming patterns.

3. No Type Hints or JSDoc

Without type information, developers have to guess parameter types. Add type hints to all SDK methods.

4. Poor Error Handling

SDKs that raise generic exceptions force developers to handle all errors the same way. Provide typed exception classes.

5. No Async Support

Modern developers expect async versions of SDK methods for non-blocking I/O.

Practice Questions

1. Why should SDKs be auto-generated from the OpenAPI spec?

Auto-generation ensures SDKs stay in sync with the API specification. Manual maintenance inevitably drifts.

2. What should every SDK include besides the HTTP client code?

Installation instructions, quickstart example, full API reference, error handling guide, and Migration guide.

3. Why is naming consistency important across SDKs?

Developers who switch between languages expect the same method names and patterns. Inconsistency creates confusion.

4. What is the benefit of type hints in SDKs?

Type hints enable IDE autocompletion, catch type errors during development, and serve as documentation.

5. Challenge: Generate a Python SDK from an OpenAPI 3.0 specification using OpenAPI Generator. Write the SDK documentation including installation, quickstart, and error handling sections.

FAQ

Mini Project

Create an OpenAPI specification for an API with three endpoints. Use OpenAPI Generator to create Python and JavaScript SDKs. Document each SDK with installation instructions, a quickstart example, and an API reference. Include type hints and error handling.

What's Next

With SDKs documented, learn about the Code Playground that lets developers test API calls directly from the documentation using Swagger UI or similar tools.