The Labs64 NetLicensing RESTful API gives you access to NetLicensing’s core features.

Authentication
You authenticate to the NetLicensing API by providing your account credentials or simply use our demo account - demo:demo

Find out more about Labs64 NetLicensing at netlicensing.io

This is an online openapi generator server. You can find out more at https://github.com/OpenAPITools/openapi-generator.

This is the API for OpenAPI space.

An OpenAPI description of the OpenLink Smart Data Bot REST API v1

The _Open Build Service API_ is a XML API. To authenticate, use [HTTP basic authentication](https://en.wikipedia.org/wiki/Basic_access_authentication) by passing the _Authorization_ header in the form of `Authorization: Basic `. There is no API versioning as there is no need for it right now. Only rudimentary rate limiting is implemented, so please be gentle when using the API concurrently, especially with potentially expensive operations. In case of abuse, we will limit/remove your access. For command-line users, we recommend using [osc](https://github.com/openSUSE/osc) with its _api_ command to interact with the API. It's as simple as this example: `osc api /about` (_about_ is one of the endpoints documented below)

Validate and generate passwords using open source tools

An API to generate charts and QR codes using QuickChart services.

ADVICEment's [DynamicDocs API automates your document generation](https://advicement.io/dynamic-documents-api) and creates dynamic, optimized, interactive PDFs. Write your templates in LaTeX and call the API with JSON data to get your PDFs in seconds. The template files are stored in your dashboard and can be edited, tested and published online. Document templates can contain dynamic text using logic statements, include tables stretching multiple pages and show great-looking charts based on the underlying data. LaTeX creates crisp, high-quality documents where every detail is well-positioned and styled. Integrate with ADVICEment DynamicDocs API in minutes and start creating beautiful [dynamic PDF documents](https://advicement.io/dynamic-documents-api) for your needs. For more information, visit [DynamicDocs API Home page](https://advicement.io/dynamic-documents-api).

RESTful API of [Request Baskets](https://rbaskets.in) service. Request Baskets is an open source project of a service to collect HTTP requests and inspect them via RESTful API or web UI. Check out the [project page](https://github.com/darklynx/request-baskets) for more detailed description.

Create beautiful product and API documentation with our developer friendly platform.

Catalog Inventory

API of the Patch application on [cloud.redhat.com](cloud.redhat.com) Syntax of the `filter[name]` query parameters is described in [Filters documentation](https://github.com/RedHatInsights/patchman-engine/wiki/API-custom-filters)

Remove the background of any image

RESTful API 4 Unipacker

Download OpenAPI specification: [openapi.yml](openapi.yml) # Introduction Rudder exposes a REST API, enabling the user to interact with Rudder without using the webapp, for example in scripts or cronjobs. ## Versioning Each time the API is extended with new features (new functions, new parameters, new responses, ...), it will be assigned a new version number. This will allow you to keep your existing scripts (based on previous behavior). Versions will always be integers (no 2.1 or 3.3, just 2, 3, 4, ...) or `latest`. You can change the version of the API used by setting it either within the url or in a header: * the URL: each URL is prefixed by its version id, like `/api/version/function`. ```bash # Version 10 curl -X GET -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/10/rules # Latest curl -X GET -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/latest/rules # Wrong (not an integer) => 404 not found curl -X GET -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/3.14/rules ``` * the HTTP headers. You can add the **X-API-Version** header to your request. The value needs to be an integer or `latest`. ```bash # Version 10 curl -X GET -H "X-API-Token: yourToken" -H "X-API-Version: 10" https://rudder.example.com/rudder/api/rules # Wrong => Error response indicating which versions are available curl -X GET -H "X-API-Token: yourToken" -H "X-API-Version: 3.14" https://rudder.example.com/rudder/api/rules ``` In the future, we may declare some versions as deprecated, in order to remove them in a later version of Rudder, but we will never remove any versions without warning, or without a safe period of time to allow migration from previous versions.

Existing versions

Version	Rudder versions it appeared in	Description
1	Never released (for internal use only)	Experimental version
2 to 10 (deprecated)	4.3 and before	These versions provided the core set of API features for rules, directives, nodes global parameters, change requests and compliance, rudder settings and system API
11	5.0	New system API (replacing old localhost v1 api): status, maintenance operations and server behavior
12	6.0 and 6.1	Node key management
13	6.2	Node status endpoint System health check System maintenance job to purge software [that endpoint was back-ported in 6.1]
14	7.0	Secret management Directive tree Improve techniques management Demote a relay
15	7.1	Package updates in nodes
16	7.2	Create node API included from plugin Configuration archive import/export

## Response format All responses from the API are in the JSON format. ```json { "action": "The name of the called function", "id": "The ID of the element you want, if relevant", "result": "The result of your action: success or error", "data": "Only present if this is a success and depends on the function, it's usually a JSON object", "errorDetails": "Only present if this is an error, it contains the error message" } ``` * __Success__ responses are sent with the 200 HTTP (Success) code * __Error__ responses are sent with a HTTP error code (mostly 5xx...) ## HTTP method Rudder's REST API is based on the usage of [HTTP methods](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html). We use them to indicate what action will be done by the request. Currently, we use four of them: * **GET**: search or retrieve information (get rule details, get a group, ...) * **PUT**: add new objects (create a directive, clone a Rule, ...) * **DELETE**: remove objects (delete a node, delete a parameter, ...) * **POST**: update existing objects (update a directive, reload a group, ...) ## Parameters ### General parameters Some parameters are available for almost all API functions. They will be described in this section. They must be part of the query and can't be submitted in a JSON form. #### Available for all requests

Field	Type	Description
prettify	boolean optional	Determine if the answer should be prettified (human friendly) or not. We recommend using this for debugging purposes, but not for general script usage as this does add some unnecessary load on the server side. Default value: false

#### Available for modification requests (PUT/POST/DELETE)

Field	Type	Description
reason	string optional or required	Set a message to explain the change. If you set the reason messages to be mandatory in the web interface, failing to supply this value will lead to an error. Default value: ""
changeRequestName	string optional	Set the change request name, is used only if workflows are enabled. The default value depends on the function called Default value: A default string for each function
changeRequestDescription	string optional	Set the change request description, is used only if workflows are enabled. Default value: ""

### Passing parameters Parameters to the API can be sent: * As part of the URL for resource identification * As data for POST/PUT requests * Directly in JSON format * As request arguments #### As part of the URL for resource identification Parameters in URLs are used to indicate which resource you want to interact with. The function will not work if this resource is missing. ```bash # Get the Rule of ID "id" curl -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/latest/rules/id ``` CAUTION: To avoid surprising behavior, do not put a '/' at the end of an URL: it would be interpreted as '/[empty string parameter]' and redirected to '/index', likely not what you wanted to do. #### Sending data for POST/PUT requests ##### Directly in JSON format JSON format is the preferred way to interact with Rudder API for creating or updating resources. You'll also have to set the *Content-Type* header to **application/json** (without it the JSON content would be ignored). In a `curl` `POST` request, that header can be provided with the `-H` parameter: ```bash curl -X POST -H "Content-Type: application/json" ... ``` The supplied file must contain a valid JSON: strings need quotes, booleans and integers don't, etc. The (human readable) format is: ```json { "key1": "value1", "key2": false, "key3": 42 } ``` Here is an example with inlined data: ```bash # Update the Rule 'id' with a new name, disabled, and setting it one directive curl -X POST -H "X-API-Token: yourToken" -H "Content-Type: application/json" https://rudder.example.com/rudder/api/rules/latest/{id} -d '{ "displayName": "new name", "enabled": false, "directives": "directiveId"}' ``` You can also pass a supply the JSON in a file: ```bash # Update the Rule 'id' with a new name, disabled, and setting it one directive curl -X POST -H "X-API-Token: yourToken" -H "Content-Type: application/json" https://rudder.example.com/rudder/api/rules/latest/{id} -d @jsonParam ``` Note that the general parameters view in the previous chapter cannot be passed in a JSON, and you will need to pass them a URL parameters if you want them to be taken into account (you can't mix JSON and request parameters): ```bash # Update the Rule 'id' with a new name, disabled, and setting it one directive with reason message "Reason used" curl -X POST -H "X-API-Token: yourToken" -H "Content-Type: application/json" "https://rudder.example.com/rudder/api/rules/latest/{id}?reason=Reason used" -d @jsonParam -d "reason=Reason ignored" ``` ##### Request parameters In some cases, when you have little, simple data to update, JSON can feel bloated. In such cases, you can use request parameters. You will need to pass one parameter for each data you want to change. Parameters follow the following schema: ``` key=value ``` You can pass parameters by two means: * As query parameters: At the end of your url, put a **?** then your first parameter and then a **&** before next parameters. In that case, parameters need to be https://en.wikipedia.org/wiki/Percent-encoding[URL encoded] ```bash # Update the Rule 'id' with a new name, disabled, and setting it one directive curl -X POST -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/rules/latest/{id}?"displayName=my new name"&"enabled=false"&"directives=aDirectiveId" ``` * As request data: You can pass those parameters in the request data, they won't figure in the URL, making it lighter to read, You can pass a file that contains data. ```bash # Update the Rule 'id' with a new name, disabled, and setting it one directive (in file directive-info.json) curl -X POST -H "X-API-Token: yourToken" https://rudder.example.com/rudder/api/rules/latest/{id} -d "displayName=my new name" -d "enabled=false" -d @directive-info.json ```