Open Skills Getting Started: Account, Keys, and First Request (2026)

Getting started overview

Getting started with Open Skills involves a sequence of steps to configure your access and make your first API call. The process begins with account creation, followed by the generation of API keys for authentication. Once authenticated, developers can use cURL or one of the official SDKs to interact with the Open Skills platform. The platform is designed to provide programmatic access to skills taxonomy management, job description enrichment, candidate matching, and labor market analysis capabilities, primarily through its Skills, Jobs, and Profiles APIs.

The following table outlines the key steps to initiate development with Open Skills:

Create an account and get keys

To begin using Open Skills, you must first create an account on their platform. This registration process typically involves providing an email address and setting a password. Upon successful registration, you will gain access to a dashboard where API credentials can be managed. Open Skills offers a free tier that includes up to 100,000 API calls per month, which is suitable for initial development and testing.

After creating your account, the next critical step is to obtain your API keys. These keys are used to authenticate your requests to the Open Skills API and ensure that only authorized applications can access your account's resources. The exact location for generating API keys can vary but is generally found within a 'Developer Settings', 'API Keys', or 'Credentials' section of your Open Skills account dashboard. It is customary for platforms to provide both public and secret keys, or a single API key, depending on their security model. For Open Skills, these keys are essential for authenticating all subsequent API interactions, as detailed in the Open Skills authentication guide.

When handling your API keys, adhere to security best practices:

• Do not hardcode keys: Avoid embedding API keys directly into your source code. Instead, use environment variables or a secure configuration management system.
• Keep keys secret: Treat your API keys as sensitive information. Do not share them publicly or commit them to version control systems like Git without proper encryption and access control.
• Rotate keys regularly: Periodically generate new keys and revoke old ones to minimize the risk of compromise.

Platforms like Google Cloud also emphasize the importance of securing API keys to prevent unauthorized usage and potential service abuse. Following these guidelines helps maintain the security and integrity of your application and Open Skills account.

Your first request

Once you have an Open Skills account and API key, you can make your first authenticated request. This section provides examples using cURL, Python, and TypeScript, which are among the supported SDKs for Open Skills.

Using cURL

cURL is a command-line tool for making HTTP requests and is useful for quickly testing API endpoints without writing code. Replace YOUR_API_KEY with your actual Open Skills API key.

curl -X GET \
  "https://api.openskill.sh/v1/skills" \
  -H "Authorization: Bearer YOUR_API_KEY"

This cURL command requests a list of available skills from the Skills API endpoint. A successful response will return a JSON array of skill objects.

Using Python SDK

First, install the Open Skills Python SDK:

pip install openskill-sdk

Then, you can make a request to the Skills API:

import os
from openskill_sdk import OpenSkillsClient

# It's recommended to store your API key in an environment variable
api_key = os.environ.get("OPEN_SKILLS_API_KEY")

if not api_key:
    raise ValueError("OPEN_SKILLS_API_KEY environment variable not set.")

client = OpenSkillsClient(api_key=api_key)

try:
    # Fetch a list of skills
    skills = client.skills.list()
    for skill in skills.data:
        print(f"Skill ID: {skill.id}, Name: {skill.name}")
except Exception as e:
    print(f"An error occurred: {e}")

This Python example initializes the client with your API key and then calls the skills.list() method to retrieve skills data. The API key is loaded from an environment variable named OPEN_SKILLS_API_KEY for security.

Using TypeScript SDK

First, install the Open Skills TypeScript SDK:

npm install openskill-sdk
# or
yarn add openskill-sdk

Then, you can make a request to the Skills API:

import { OpenSkillsClient } from 'openskill-sdk';

// It's recommended to store your API key in an environment variable
const apiKey = process.env.OPEN_SKILLS_API_KEY;

if (!apiKey) {
    throw new Error("OPEN_SKILLS_API_KEY environment variable not set.");
}

const client = new OpenSkillsClient(apiKey);

async function getSkills() {
    try {
        const response = await client.skills.list();
        response.data.forEach(skill => {
            console.log(`Skill ID: ${skill.id}, Name: ${skill.name}`);
        });
    } catch (error) {
        console.error("An error occurred:", error);
    }
}

getSkills();

Similar to the Python example, this TypeScript code initializes the client and fetches skills. The API key is retrieved from an environment variable to maintain security. The async/await pattern is used for handling the asynchronous API call.

Common next steps

After successfully making your first API call, you can explore the broader capabilities of Open Skills. Common next steps for integrating Open Skills into an application or workflow include:

• Explore other APIs: Beyond the basic Skills API, investigate the Jobs API for job description processing and parsing, and the Profiles API for candidate profile analysis and matching.
• Implement advanced queries: Learn how to filter, sort, and paginate results, and how to perform more complex queries for specific skills or job requirements. The Open Skills documentation provides details on these advanced features.
• Integrate with your application: Incorporate the SDKs or direct API calls into your existing application logic. This might involve building a UI to display skill data, automating job posting enrichment, or enhancing a candidate matching engine. Many developers use API integration platforms like Tray.io or Kong to manage and orchestrate API calls within larger systems.
• Monitor API usage: Keep track of your API call volume to stay within your Free tier limits or monitor usage against your paid plan. Your Open Skills dashboard typically provides usage metrics.
• Handle errors gracefully: Implement robust error handling in your code to manage API rate limits, invalid requests, or server-side issues. Refer to the Open Skills error codes documentation for specific responses.
• Consider Webhooks: If Open Skills offers webhooks (check their documentation), consider using them for real-time notifications about data changes or events, rather than polling the API. This can improve efficiency and responsiveness.

Troubleshooting the first call

When making your initial API call, you might encounter issues. Here are common problems and their solutions:

• Authentication error (401 Unauthorized):
  • Issue: Your API key is incorrect, missing, or expired.
  • Solution: Double-check that you are using the correct API key from your Open Skills dashboard. Ensure it is included in the Authorization: Bearer YOUR_API_KEY header for cURL and correctly passed to the SDK client. Generate a new key if uncertain or if the existing one might be compromised.
• Bad Request (400):
  • Issue: The request body or parameters are malformed or invalid.
  • Solution: Review the Open Skills API reference for the specific endpoint you are calling. Ensure that all required parameters are present and correctly formatted (e.g., JSON syntax is valid, data types match expectations).
• Not Found (404):
  • Issue: The API endpoint URL is incorrect, or the resource you are requesting does not exist.
  • Solution: Verify the API endpoint URL against the Open Skills API documentation. Ensure there are no typos in the path. If querying for a specific ID, confirm that the ID is valid and exists.
• Rate Limit Exceeded (429 Too Many Requests):
  • Issue: You have sent too many requests in a given time period, exceeding your plan's limits.
  • Solution: Implement exponential backoff or other rate-limiting strategies in your application. Check your Open Skills dashboard for your current rate limits and usage. Consider upgrading your plan if sustained higher throughput is required.
• Server Error (5xx):
  • Issue: An unexpected error occurred on the Open Skills server.
  • Solution: These are typically temporary issues. Wait a few moments and retry the request. If the problem persists, check the Open Skills status page (if available) or contact their support team with the request ID or error details.
• SDK-specific errors:
  • Issue: Errors related to SDK installation or configuration.
  • Solution: Ensure the SDK is correctly installed and its version is compatible with your project. Consult the Open Skills SDK documentation for language-specific setup instructions and common issues.