Introduction

Trendence exposes parts of its architecture for integrational use, intended to fuel your custom applications and systems with data and proper exports. This system is what we call our Talent Intelligence API. These documentation pages are intended to help you getting started.

Base URL: https://api.trendence.com/v1/

API Version: 0.1.0

Authentication

To authorize, use this code:

# With Bearer Token (recommended)
curl "https://api.trendence.com/v1/talents" \
  -H "Authorization: Bearer YOUR_API_KEY"

require 'net/http'
require 'uri'

uri = URI.parse("https://api.trendence.com/v1/talents")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Content-Type"] = "application/json"

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}

response = requests.post(
    'https://api.trendence.com/v1/talents',
    headers=headers
)

const fetch = require('node-fetch');

fetch('https://api.trendence.com/v1/talents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});

Make sure to replace YOUR_API_KEY with your actual API key.

The Trendence API uses API keys for authentication. Every request must include a valid API key.

Authentication Methods

You can provide your API key in two ways:

Bearer Token (Recommended)

Send the API key in the Authorization header as a Bearer token:

Authorization: Bearer YOUR_API_KEY

X-API-Key Header

Alternatively, you can use the X-API-Key header:

X-API-Key: YOUR_API_KEY

Content-Type Required

For all POST, PUT, and PATCH requests, the Content-Type header must be set to application/json.

Otherwise, you will receive a 415 Unsupported Media Type error.

Security Recommendations

Keep your API key secret: Never share your API key publicly or in version control systems.
Use environment variables: Store API keys in environment variables instead of source code.
Use HTTPS: All API requests are required to be made over HTTPS.
Rotate keys regularly: Request a new API key when needed.

Talents

Create Talent Analysis

curl --request POST \
  --url "https://api.trendence.com/v1/talents" \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "talent": {
      "description": "Experienced Full-Stack Developer with 5 years of professional experience. Expertise in React, Node.js, and Python."
    }
  }'

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://api.trendence.com/v1/talents")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "talent" => {
    "description" => "Experienced Full-Stack Developer with 5 years..."
  }
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

import requests
import json

url = "https://api.trendence.com/v1/talents"
headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}
data = {
    'talent': {
        'description': 'Experienced Full-Stack Developer with 5 years...'
    }
}

response = requests.post(url, headers=headers, json=data)

const fetch = require('node-fetch');

const url = 'https://api.trendence.com/v1/talents';
const data = {
  talent: {
    description: 'Experienced Full-Stack Developer with 5 years...'
  }
};

fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => console.log(data));

The above command returns JSON structured like this:

{
  "meta": {
    "tie": {
      "version": "0.0.1"
    }
  },
  "status": "pending",
  "hints": "The data is being prepared, please check talent_url for an update.",
  "talent_uuid": "550e8400-e29b-41d4-a716-446655440000",
  "talent_url": "https://api.trendence.com/v1/talents/550e8400-e29b-41d4-a716-446655440000"
}

This endpoint creates a new asynchronous talent analysis.

HTTP Request

POST https://api.trendence.com/v1/talents

Request Body Parameters

Parameter	Type	Required	Description
talent_text.description	String	Yes	Description of the talent in natural language
language	String	No	Language code for the analysis (e.g., "de", "en")
location.country	String	Yes	ISO 3166-1 alpha-2 country code (e.g., "DE", "AT", "CH")
location.region	String	No	Region or city name (e.g., "Berlin", "Bavaria")
location.coordinates.lat	String	No	Latitude coordinate
location.coordinates.lng	String	No	Longitude coordinate

Query Parameters

Parameter	Type	Default	Description
force_sync	Boolean	false	When `true`, processes synchronously (max. 29 seconds)

Response

The API processes requests asynchronously by default. Upon successful acceptance, you will receive a 202 Accepted response.

The response includes a talent_url that you can poll to check the status of your analysis.

Get Talent Analysis

curl --request GET \
  --url "https://api.trendence.com/v1/talents/550e8400-e29b-41d4-a716-446655440000" \
  --header "Authorization: Bearer YOUR_API_KEY"

require 'net/http'
require 'uri'

uuid = "550e8400-e29b-41d4-a716-446655440000"
uri = URI.parse("https://api.trendence.com/v1/talents/#{uuid}")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

import requests

uuid = "550e8400-e29b-41d4-a716-446655440000"
url = f"https://api.trendence.com/v1/talents/{uuid}"
headers = {'Authorization': 'Bearer YOUR_API_KEY'}

response = requests.get(url, headers=headers)

const uuid = '550e8400-e29b-41d4-a716-446655440000';
const url = `https://api.trendence.com/v1/talents/${uuid}`;

fetch(url, {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
})
.then(response => response.json())
.then(data => console.log(data));

When processing is complete (200 OK):

{
  "meta": {
    "tie": {
      "version": "0.0.1"
    }
  },
  "status": "completed",
  "talent_uuid": "550e8400-e29b-41d4-a716-446655440000",
  "request": {
    "talent_text": {
      "description": "Experienced Full-Stack Developer with 5 years..."
    },
    "language": "en",
    "location": {
      "country": "DE",
      "region": "Berlin"
    }
  },
  "results": [{
    "skillset_id": "12345",
    "skillset_label": "Software Development",
    "vacancies": {
      "vacancies": [
        {
          "location": "Berlin",
          "similarity": 0.9466,
          "vacancy_url": "https://jobportal24.example/view/abc123",
          "vacancy_title": "Senior Full Stack Developer (m/f/d)",
          "organization_name": "TechCorp GmbH",
          "vacancy_publish_date": "2025-06-08"
        },
        {
          "location": "Munich",
          "similarity": 0.9234,
          "vacancy_url": "https://careersite.example/jobs/def456",
          "vacancy_title": "Full Stack Engineer",
          "organization_name": "InnovateLabs AG",
          "vacancy_publish_date": "2025-06-15"
        }
      ],
      "vacancy_sources": [{
        "date": null,
        "sources": [
          {"count": 45821, "share": 0.312, "source": "jobportal24.example"},
          {"count": 28934, "share": 0.197, "source": "careersite.example"},
          {"count": 19283, "share": 0.131, "source": "hiringboard.example"}
        ]
      }],
      "vacancy_employers": [{
        "date": null,
        "employers": [
          {"count": 342, "share": 0.089, "employer": "TechCorp GmbH"},
          {"count": 287, "share": 0.075, "employer": "InnovateLabs AG"},
          {"count": 215, "share": 0.056, "employer": "Digital Solutions GmbH"}
        ]
      }]
    },
    "labour_market": {
      "salary": {
        "q10": 52000, "q20": 58000, "q30": 63000, "q40": 68000,
        "q50": 72000, "q60": 76000, "q70": 81000, "q80": 87000, "q90": 95000
      },
      "scarcity": {
        "scarcity_index": 7.8,
        "vacancy_duration": "high",
        "campaigns_repeated": "very high",
        "job_change_reluctance": "low",
        "median_earnings_change": "high"
      },
      "vacancies_count": [
        {"date": "2025-04-01", "vacancies": 156},
        {"date": "2025-05-01", "vacancies": 178}
      ],
      "kldb_vacancies_jobseekers_ratio": [
        {"date": "2025-04-01", "vacancies": 1245, "jobseekers": 3890,
         "vacancies_jobseekers_ratio": 0.32}
      ]
    },
    "matched_profession_profile": {
      "tool": ["React", "Node.js", "Docker", "Git"],
      "hardsskill": ["JavaScript", "TypeScript", "REST APIs", "SQL"],
      "softsskill": ["Communication", "Problem Solving"],
      "responsibility": ["Develop web applications", "Code reviews", "Team collaboration"],
      "similar_titles": ["Full Stack Developer", "Software Engineer", "Web Developer"]
    }
  }]
}

This endpoint retrieves the status or result of a talent analysis.

The results array contains matching vacancy data including job postings, similarity scores, labour market analytics (salary, scarcity index), and statistics about vacancy sources and employers. See Understanding Talent Responses for detailed field descriptions.

HTTP Request

GET https://api.trendence.com/v1/talents/:uuid

URL Parameters

Parameter	Description
uuid	The UUID of the talent analysis to retrieve

Response Status Codes

Status	Meaning
202 Accepted	Analysis is still processing
200 OK	Analysis is complete, result available
502 Bad Gateway	Processing error occurred

Understanding Talent Responses

When you submit a talent description, the API performs intelligent job matching and returns four key types of information:

Matching Job Vacancies - A ranked list of relevant job opportunities with similarity scores, enabling you to present the best-fitting positions to job seekers.
Labour Market Analytics - Salary quantiles (q10-q90) and recruitment complexity metrics including the Recruitment Complexity Index (scarcity_index), helping candidates understand compensation expectations and their market value.
Market Intelligence - Insights into where these jobs are posted (sources) and which employers are hiring, helping you understand the job market landscape.
Talent Profile - Extracted skills, tools, responsibilities, and matching job titles from the talent description.

Response Structure

Field	Type	Description
`results`	Array	Analysis results (typically one element)
`results[].vacancies`	Object	Vacancy-related data
`results[].labour_market`	Object	Salary and recruitment complexity metrics
`results[].matched_profession_profile`	Object	Extracted skills and profile data
`results[].skillset_id`	String	Internal skillset classification ID
`results[].skillset_label`	String	Human-readable skillset label

Vacancy Fields

Field	Description	Usage Notes
`location`	Geographic location	Filter by candidate's preferred location
`similarity`	Match quality (0-1)	Higher values indicate better match between talent and vacancy
`vacancy_url`	Direct link to posting	Provide to candidates for easy application
`vacancy_title`	Job position title	Display prominently in your UI
`organization_name`	Hiring organization	Useful for company preference filtering
`vacancy_publish_date`	Publication date (YYYY-MM-DD)	Prioritize recent postings

Labour Market Data

Field	Description	Usage Notes
`salary.q10` - `salary.q90`	Salary quantiles	Annual salary in local currency; q50 is median
`scarcity.scarcity_index`	Recruitment Complexity Index (0-10)	Higher = harder to find candidates = better market value
`scarcity.vacancy_duration`	Time to fill	Values: `low`, `high`, `very high`
`scarcity.campaigns_repeated`	Reposting frequency	`very high` = candidate scarcity = strong negotiating position
`scarcity.median_earnings_change`	Salary growth when switching jobs	`very high` = potential for salary increases
`vacancies_count[]`	Historical vacancy volume	Monthly time series showing demand trends
`kldb_vacancies_jobseekers_ratio[]`	Supply-demand ratio	Higher ratio = tighter labor market = better prospects

Profession Profile

Field	Description
`tool`	Technical tools and platforms identified (e.g., "React", ".NET Core")
`hardsskill`	Technical competencies detected (e.g., "Typescript", "Angular")
`softsskill`	Non-technical competencies
`responsibility`	Experience areas and capabilities
`similar_titles`	Job titles matching the talent's profile

The scarcity_index (Recruitment Complexity Index) helps candidates understand their market value. Higher values indicate greater difficulty finding qualified candidates, which typically correlates with better compensation and negotiating power.

Polling Strategy

For asynchronous requests, we recommend using exponential backoff when polling for results.

Professions

Create Profession Analysis

curl --request POST \
  --url "https://api.trendence.com/v1/professions" \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "profession_text": {
      "title": "Full Stack Developer",
      "description": "Full Stack Developer with over 10 years of experience..."
    },
    "language": "de",
    "location": {
      "country": "DE"
    }
  }'

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://api.trendence.com/v1/professions")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "profession_text" => {
    "title" => "Full Stack Developer",
    "description" => "Full Stack Developer with over 10 years..."
  },
  "language" => "de",
  "location" => {
    "country" => "DE"
  }
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

import requests

url = "https://api.trendence.com/v1/professions"
headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}
data = {
    'profession_text': {
        'title': 'Full Stack Developer',
        'description': 'Full Stack Developer with over 10 years...'
    },
    'language': 'de',
    'location': {
        'country': 'DE'
    }
}

response = requests.post(url, headers=headers, json=data)

const fetch = require('node-fetch');

const url = 'https://api.trendence.com/v1/professions';
const data = {
  profession_text: {
    title: 'Full Stack Developer',
    description: 'Full Stack Developer with over 10 years...'
  },
  language: 'de',
  location: {
    country: 'DE'
  }
};

fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => console.log(data));

The above command returns JSON structured like this:

{
  "meta": {
    "tie": {
      "version": "0.0.1"
    }
  },
  "status": "pending",
  "hints": "The data is being prepared, please check professions_url for an update.",
  "professions_uuid": "660e8400-e29b-41d4-a716-446655440001",
  "professions_url": "https://api.trendence.com/v1/professions/660e8400-e29b-41d4-a716-446655440001"
}

This endpoint creates a new asynchronous profession analysis.

HTTP Request

POST https://api.trendence.com/v1/professions

Request Body Parameters

Parameter	Type	Required	Description
profession_text.title	String	Yes	Job title
profession_text.description	String	Yes	Description of the profession in natural language
language	String	No	Language code for the analysis (e.g., "de", "en")
location.country	String	Yes	ISO 3166-1 alpha-2 country code (e.g., "DE", "AT", "CH")
location.region	String	No	Region or city name (e.g., "Munich", "Bavaria")
location.coordinates.lat	String	No	Latitude coordinate
location.coordinates.lng	String	No	Longitude coordinate

Query Parameters

Parameter	Type	Default	Description
force_sync	Boolean	false	When `true`, processes synchronously (max. 29 seconds)

Get Profession Analysis

curl --request GET \
  --url "https://api.trendence.com/v1/professions/660e8400-e29b-41d4-a716-446655440001" \
  --header "Authorization: Bearer YOUR_API_KEY"

require 'net/http'
require 'uri'

uuid = "660e8400-e29b-41d4-a716-446655440001"
uri = URI.parse("https://api.trendence.com/v1/professions/#{uuid}")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

import requests

uuid = "660e8400-e29b-41d4-a716-446655440001"
url = f"https://api.trendence.com/v1/professions/{uuid}"
headers = {'Authorization': 'Bearer YOUR_API_KEY'}

response = requests.get(url, headers=headers)

const uuid = '660e8400-e29b-41d4-a716-446655440001';
const url = `https://api.trendence.com/v1/professions/${uuid}`;

fetch(url, {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
})
.then(response => response.json())
.then(data => console.log(data));

When processing is complete (200 OK):

{
  "meta": {
    "tie": {
      "version": "0.0.1"
    }
  },
  "status": "completed",
  "professions_uuid": "660e8400-e29b-41d4-a716-446655440001",
  "request": {
    "profession_text": {
      "title": "Senior Full Stack Developer",
      "description": "Full Stack Developer with over 10 years of experience in Java, JavaScript, React, Python..."
    },
    "language": "de",
    "location": {
      "country": "DE"
    }
  },
  "results": [{
    "vacancies": {
      "vacancies": [
        {
          "location": "München",
          "similarity": 0.9430,
          "vacancy_url": "https://talentboard.example/jobs/xyz789",
          "vacancy_title": "Senior Fullstack Developer (w/m/d)",
          "organization_name": "SoftwareHouse GmbH",
          "vacancy_publish_date": "2025-06-19"
        },
        {
          "location": "Hamburg",
          "similarity": 0.9201,
          "vacancy_url": "https://careerplatform.example/positions/ghi012",
          "vacancy_title": "Full Stack Engineer",
          "organization_name": "CloudTech AG",
          "vacancy_publish_date": "2025-06-22"
        }
      ],
      "vacancy_sources": [{
        "date": null,
        "sources": [
          {"count": 82341, "share": 0.245, "source": "talentboard.example"},
          {"count": 61829, "share": 0.184, "source": "careerplatform.example"},
          {"count": 43567, "share": 0.130, "source": "jobfinder.example"}
        ]
      }],
      "vacancy_employers": [{
        "date": null,
        "employers": [
          {"count": 428, "share": 0.112, "employer": "SoftwareHouse GmbH"},
          {"count": 356, "share": 0.093, "employer": "CloudTech AG"},
          {"count": 289, "share": 0.076, "employer": "DevOps Solutions GmbH"}
        ]
      }]
    },
    "labour_market": {
      "salary": {
        "q10": 63300, "q20": 68900, "q30": 72800, "q40": 76300,
        "q50": 79700, "q60": 83000, "q70": 86700, "q80": 91400, "q90": 100700
      },
      "scarcity": {
        "scarcity_index": 8.1,
        "vacancy_duration": "high",
        "campaigns_repeated": "very high",
        "job_change_reluctance": "very low",
        "median_earnings_change": "very high",
        "avg_postings_per_campaign": "very low",
        "foreign_employee_share_change": "very high",
        "job_adds_people_available_ratio": "high"
      },
      "vacancies_count": [
        {"date": "2025-04-01", "vacancies": 21},
        {"date": "2025-05-01", "vacancies": 20},
        {"date": "2025-06-01", "vacancies": 32}
      ],
      "kldb_vacancies_jobseekers_ratio": [
        {"date": "2025-04-01", "vacancies": 892, "jobseekers": 11821,
         "vacancies_jobseekers_ratio": 0.075, "vacancies_jobseekers_ratio_log": 0.023}
      ]
    },
    "matched_profession_profile": {
      "tool": ["React", ".NET Core", "OpenAPI", "Docker"],
      "hardsskill": ["Typescript", "Angular", "Java", "Python"],
      "softsskill": ["Kritisches Denken", "Teamarbeit"],
      "responsibility": ["Software entwickeln", "Benutzeroberflächen optimieren", "Code Reviews durchführen"],
      "similar_titles": ["Entwickler Fullstack", "Developer", "Software Engineer"]
    }
  }]
}

This endpoint retrieves the status or result of a profession analysis.

HTTP Request

GET https://api.trendence.com/v1/professions/:uuid

URL Parameters

Parameter	Description
uuid	The UUID of the profession analysis to retrieve

Understanding Profession Responses

When you submit a profession description, the API analyzes the job requirements and returns four key types of information:

Matching Job Vacancies - A ranked list of similar job opportunities with similarity scores, enabling you to show employers comparable positions in the market.
Labour Market Analytics - Salary quantiles (q10-q90) and recruitment complexity metrics including the Recruitment Complexity Index (scarcity_index), providing insights into compensation benchmarks and hiring difficulty.
Market Intelligence - Insights into where these jobs are posted (sources) and which employers are hiring for similar roles, helping you understand competitive hiring landscapes.
Profession Profile - Extracted skills, tools, responsibilities, and similar job titles from the profession description.

Response Structure

Field	Type	Description
`results`	Array	Analysis results (typically one element)
`results[].vacancies`	Object	Vacancy-related data
`results[].labour_market`	Object	Salary and recruitment complexity metrics
`results[].matched_profession_profile`	Object	Extracted skills and profile data

Vacancy Fields

Field	Description	Usage Notes
`location`	Geographic location	Analyze regional hiring patterns
`similarity`	Match quality (0-1)	Higher values indicate better match between talent and vacancy
`vacancy_url`	Direct link to posting	For detailed job analysis or referrals
`vacancy_title`	Job position title	Shows market positioning of similar roles
`organization_name`	Hiring organization	Identify competitors or benchmarking
`vacancy_publish_date`	Publication date (YYYY-MM-DD)	Analyze hiring trends over time

Labour Market Data

Field	Description	Usage Notes
`salary.q10` - `salary.q90`	Salary quantiles	Annual salary in local currency; q50 is median. Use for compensation benchmarking
`scarcity.scarcity_index`	Recruitment Complexity Index (0-10)	Higher = greater difficulty finding candidates. Use for workforce planning
`scarcity.vacancy_duration`	Time to fill positions	Values: `low`, `high`, `very high`. Indicates typical hiring timeline
`scarcity.campaigns_repeated`	Reposting frequency	`very high` = candidate scarcity
`scarcity.median_earnings_change`	Salary growth when changing jobs	Indicates competitive pressure on compensation
`scarcity.foreign_employee_share_change`	International recruitment trend	`very high` = reliance on foreign talent
`scarcity.job_adds_people_available_ratio`	Supply-demand balance	Higher = more competition for talent
`vacancies_count[]`	Historical vacancy volume	Monthly time series data
`kldb_vacancies_jobseekers_ratio[]`	Supply-demand ratio over time	Based on official occupation classification (KLDB)

Profession Profile

Field	Description
`tool`	Technologies mentioned or inferred (e.g., "React", ".NET Core", "OpenAPI")
`hardsskill`	Technical competencies required (e.g., "Typescript", "Angular")
`softsskill`	Non-technical competencies (e.g., "Kritisches Denken")
`responsibility`	Job duties and tasks (e.g., "Software entwickeln")
`similar_titles`	Alternative titles for this profession (e.g., "Developer Full Stack")

Market Intelligence

The response includes vacancy source and employer statistics:

Vacancy Sources - Shows which job boards have the most postings for this profession type. Use to optimize job posting strategy and understand platform reach.

Vacancy Employers - Lists top hiring employers with their market share. High vacancy counts indicate strong hiring demand, useful for talent scarcity assessment.

The scarcity_index (Recruitment Complexity Index) is particularly valuable for employers. It quantifies hiring difficulty on a 0-10 scale, helping with workforce planning, salary setting, and recruitment strategy decisions.

Rate Limiting

The API is limited to 100 requests per minute for POST, PUT, and PATCH requests.

When the rate limit is exceeded, you will receive a 429 Too Many Requests status:

{
  "error": "Rate limit exceeded. Please try again later."
}

Changelog

[0.1.0] - 2025-12-01

Initial release of the Trendence TIE API
Talents Endpoint: Create and retrieve analysis of a talent's profile
Professions Endpoint: Create and retrieve analysis of a profession's profile
Asynchronous request processing with polling support
Optional synchronous processing via force_sync parameter
Bearer Token and X-API-Key authentication methods
Rate limiting (100 requests per minute for POST/PUT/PATCH)

Versioning Policy

Every request includes the API version shipped in the response metadata:

{
  "meta": {
    "tie": {
      "version": "0.0.1"
    }
  }
}

Version Numbering

Major version (X.0.0): Breaking changes that require client updates
Minor version (0.X.0): New features, backward compatible
Patch version (0.0.X): Bug fixes, backward compatible

Deprecation Policy

When endpoints or features are deprecated:

Deprecated features will be announced at least 6 months before removal
Deprecation notices will appear in this changelog and API responses
Migration guides will be provided for breaking changes

Errors

Error Code	Meaning
400	Bad Request -- Your request is invalid.
401	Unauthorized -- Your API key is wrong.
403	Forbidden -- The kitten requested is hidden for administrators only.
404	Not Found -- The specified kitten could not be found.
405	Method Not Allowed -- You tried to access a kitten with an invalid method.
406	Not Acceptable -- You requested a format that isn't json.
410	Gone -- The kitten requested has been removed from our servers.
418	I'm a teapot.
429	Too Many Requests -- You're requesting too many kittens! Slow down!
500	Internal Server Error -- We had a problem with our server. Try again later.
503	Service Unavailable -- We're temporarily offline for maintenance. Please try again later.