The largest open video games database. ### Why build on RAWG - More than 350,000 games for 50 platforms including mobiles. - Rich metadata: tags, genres, developers, publishers, individual creators, official websites, release dates, Metacritic ratings. - Where to buy: links to digital distribution services - Similar games based on visual similarity. - Player activity data: Steam average playtime and RAWG player counts and ratings. - Actively developing and constantly getting better by user contribution and our algorithms. ### Terms of Use - Free for personal use as long as you attribute RAWG as the source of the data and/or images and add an active hyperlink from every page where the data of RAWG is used. - Free for commercial use for startups and hobby projects with not more than 100,000 monthly active users or 500,000 page views per month. If your project is larger than that, email us at [api@rawg.io](mailto:api@rawg.io) for commercial terms. - No cloning. It would not be cool if you used our API to launch a clone of RAWG. We know it is not always easy to say what is a duplicate and what isn't. Drop us a line at [api@rawg.io](mailto:api@rawg.io) if you are in doubt, and we will talk it through. - You must include an API key with every request. The key can be obtained at https://rawg.io/apidocs. If you don’t provide it, we may ban your requests. __[Read more](https://rawg.io/apidocs)__.

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.

# Introduction The Rebilly API is built on HTTP. Our API is RESTful. It has predictable resource URLs. It returns HTTP response codes to indicate errors. It also accepts and returns JSON in the HTTP body. You can use your favorite HTTP/REST library for your programming language to use Rebilly's API, or you can use one of our SDKs (currently available in [PHP](https://github.com/Rebilly/rebilly-php) and [Javascript](https://github.com/Rebilly/rebilly-js-sdk)). We have other APIs that are also available. Every action from our [app](https://app.rebilly.com) is supported by an API which is documented and available for use so that you may automate any workflows necessary. This document contains the most commonly integrated resources. # Authentication When you sign up for an account, you are given your first secret API key. You can generate additional API keys, and delete API keys (as you may need to rotate your keys in the future). You authenticate to the Rebilly API by providing your secret key in the request header. Rebilly offers three forms of authentication: secret key, publishable key, JSON Web Tokens, and public signature key. - [Secret API key](#section/Authentication/SecretApiKey): used for requests made from the server side. Never share these keys. Keep them guarded and secure. - [Publishable API key](#section/Authentication/PublishableApiKey): used for requests from the client side. For now can only be used to create a [Payment Token](#operation/PostToken) and a [File token](#operation/PostFile). - [JWT](#section/Authentication/JWT): short lifetime tokens that can be assigned a specific expiration time. Never share your secret keys. Keep them guarded and secure. <!-- ReDoc-Inject: <security-definitions> --> # Errors Rebilly follow's the error response format proposed in [RFC 7807](https://tools.ietf.org/html/rfc7807) also known as Problem Details for HTTP APIs. As with our normal API responses, your client must be prepared to gracefully handle additional members of the response. ## Forbidden <RedocResponse pointer={"#/components/responses/Forbidden"} /> ## Conflict <RedocResponse pointer={"#/components/responses/Conflict"} /> ## NotFound <RedocResponse pointer={"#/components/responses/NotFound"} /> ## Unauthorized <RedocResponse pointer={"#/components/responses/Unauthorized"} /> ## ValidationError <RedocResponse pointer={"#/components/responses/ValidationError"} /> # SDKs Rebilly offers a Javascript SDK and a PHP SDK to help interact with the API. However, no SDK is required to use the API. Rebilly also offers [FramePay](https://docs.rebilly.com/docs/developer-docs/framepay/), a client-side iFrame-based solution to help create payment tokens while minimizing PCI DSS compliance burdens and maximizing the customizability. [FramePay](https://docs.rebilly.com/docs/developer-docs/framepay/) is interacting with the [payment tokens creation operation](#operation/PostToken). ## Javascript SDK Installation and usage instructions can be found [here](https://docs.rebilly.com/docs/developer-docs/sdks). SDK code examples are included in these docs. ## PHP SDK For all PHP SDK examples provided in these docs you will need to configure the `$client`. You may do it like this: ```php $client = new Rebilly\Client([ 'apiKey' => 'YourApiKeyHere', 'baseUrl' => 'https://api.rebilly.com', ]); ``` # Using filter with collections Rebilly provides collections filtering. You can use `?filter` param on collections to define which records should be shown in the response. Here is filter format description: - Fields and values in filter are separated with `:`: `?filter=firstName:John`. - Sub-fields are separated with `.`: `?filter=billingAddress.country:US`. - Multiple filters are separated with `;`: `?filter=firstName:John;lastName:Doe`. They will be joined with `AND` logic. In this example: `firstName:John` AND `lastName:Doe`. - You can use multiple values using `,` as values separator: `?filter=firstName:John,Bob`. Multiple values specified for a field will be joined with `OR` logic. In this example: `firstName:John` OR `firstName:Bob`. - To negate the filter use `!`: `?filter=firstName:!John`. Note that you can negate multiple values like this: `?filter=firstName:!John,!Bob`. This filter rule will exclude all Johns and Bobs from the response. - You can use range filters like this: `?filter=amount:1..10`. - You can use gte (greater than or equals) filter like this: `?filter=amount:1..`, or lte (less than or equals) than filter like this: `?filter=amount:..10`. This also works for datetime-based fields. - You can create some [predefined values lists](https://user-api-docs.rebilly.com/#tag/Lists) and use them in filter: `?filter=firstName:@yourListName`. You can also exclude list values: `?filter=firstName:!@yourListName`. - Datetime-based fields accept values formatted using RFC 3339 like this: `?filter=createdTime:2021-02-14T13:30:00Z`. # Expand to include embedded objects Rebilly provides the ability to pre-load additional objects with a request. You can use `?expand` param on most requests to expand and include embedded objects within the `_embedded` property of the response. The `_embedded` property contains an array of objects keyed by the expand parameter value(s). You may expand multiple objects by passing them as comma-separated to the expand value like so: ``` ?expand=recentInvoice,customer ``` And in the response, you would see: ``` "_embedded": [ "recentInvoice": {...}, "customer": {...} ] ``` Expand may be utilitized not only on `GET` requests but also on `PATCH`, `POST`, `PUT` requests too. # Getting started guide Rebilly's API has over 300 operations. That's more than you'll need to implement your use cases. If you have a use case you would like to implement, please consult us for feedback on the best API operations for the task. Our getting started guide will demonstrate a basic order form use case. It will allow us to highlight core resources in Rebilly that will be helpful for many other use cases too. Within 25 minutes, you'll have sent API requests (via our console) to create a subscription order.

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)

REFUGE is a web application that seeks to provide safe restroom access for transgender, intersex, and gender nonconforming individuals.

Polls is a simple API allowing consumers to view polls and vote in them.

Remove the background of any image

RESTful API 4 Unipacker

Rev.ai provides quality speech-text recognition via a RESTful API. All public methods and objects are documented here for developer reference. For a real-time speech to text solution, use Rev.ai's [Streaming API](/docs/streaming). # Base Endpoint The base url for this version of the API is > `https://api.rev.ai/speechtotext/v1` All endpoints described in this documentation are relative to this base url. # Quick Start Follow the [getting started checklist](https://www.rev.ai/getting_started) ## Get your Access Token You can generate your [access token](#section/Authentication/Access-Token) on the [settings page](https://www.rev.ai/access_token) of your account. This access token only needs to be generated once and never expires. You can re-generate your token, however this will invalidate the previous token. ## Submit a File To submit an audio file for transcription to Rev.ai: ``` curl -X POST "https://api.rev.ai/speechtotext/v1/jobs" -H "Authorization: Bearer $REV_ACCESS_TOKEN" -H "Content-Type: application/json" -d "{\"media_url\":\"https://www.rev.ai/FTC_Sample_1.mp3\",\"metadata\":\"This is a sample submit jobs option\"}" ``` You’ll receive a response like this: ~~~ { "id": "Umx5c6F7pH7r", "created_on": "2018-09-15T05:14:38.13", "name": "sample.mp3", "metadata": "This is a sample submit jobs option for multipart", "status": "in_progress" } ~~~ The `id` (in this case `Umx5c6F7pH7r`) will allow you to retrieve your transcript. ## Get Your Transcript Once a transcription job's `status` becomes `transcribed`, you can retrieve the transcript in JSON format by running: ``` curl -X GET "https://api.rev.ai/speechtotext/v1/jobs/{id}/transcript" -H "Authorization: Bearer $REV_ACCESS_TOKEN" -H "Accept: application/vnd.rev.transcript.v1.0+json" ``` Alternatively you can get the plain text version by running: ``` curl -X GET "https://api.rev.ai/speechtotext/v1/jobs/{id}/transcript" -H "Authorization: Bearer $REV_ACCESS_TOKEN" -H "Accept: text/plain" ``` You can poll for the `status` of your job by querying for the job periodically: ``` curl -X GET https://api.rev.ai/speechtotext/v1/jobs/{id} -H "Authorization: Bearer $REV_ACCESS_TOKEN" ``` **Note:** Polling is NOT recommended in a production server. Rather, use [webhooks](#section/Webhooks) to asynchronously receive notifications once the transcription job completes If you have any further questions, contact us at # Submitting Files Two `POST` request formats can be used to submit a file: `application/json` or `multipart/form-data`. ## JSON This is the preferred method of file submission. Uses the `media_url` property to provide a direct download URL to the Rev.ai server. This method supports the use of pre-signed URLs. Links to videos hosted on platforms like Youtube are not valid because they are not direct download links. **Important note on presigned URLs:** Signed URLs usually have an expiration time which is configurable. To ensure the Rev.ai server can access the link, make sure the expiration time is set to 2 hours or more. In the event you plan on resending the same file, make sure to generate a new presigned URL. ## FormData Used to send a local file to the Rev.ai server. This allows the customer to send the file directly from the host machine. Certain limits apply to this format, see the [Async API Limits section](#section/Async-API-Limits) for more detals. # Turnaround Time and Chunking Often, especially for shorter files, your transcript will be ready in 5 minutes or less. It generally takes no longer than 15 minutes to return longer audios. If you require faster turn around time please contact Chunking is the act of breaking audio files into smaller segments. Rev.ai uses this method to decrease turnaround time of audios greater than 3 minutes in length. # Webhooks If the optional `callback_url` is provided, the API will make an HTTP POST request to the `callback_url` with the following request body when the job either completes successfully or fails. ## Sample Webhook **On Successful Transcription Job** ``` { "job": { "id": "Umx5c6F7pH7r", "status": "transcribed", "created_on": "2018-05-05T23:23:22.29Z", "callback_url": "https://www.example.com/callback", "duration_seconds": 356.24, "media_url": "https://www.rev.ai/FTC_Sample_1.mp3" } } ``` **On Failed Transcription Job** ``` { "job": { "id": "Umx5c6F7pH7r", "status": "failed", "created_on": "2018-05-05T23:23:22.29Z", "callback_url": "https://www.example.com/callback", "failure": "download_failure", "failure_detail": "Failed to download media file. Please check your url and file type" } } ``` **Important notes for using webhooks:** The API will make a POST request, not a GET request, to the `callback_url`. The request body is the job details. You can unsubscribe from a webhook by responding to the webhook request with a 200 response. If a webhook invocation does not receive a 200 Rev.ai will retry the `callback_url` every 30 minutes until either 24 hours have passed or we receive a 200 response. For initial webhook testing, you can try using a third party webhook testing tool such as [https://webhook.site/](https://webhook.site/). # Async API Limits The following default limits apply per user, per endpoint and are configurable by Rev.ai support. If you have any further questions, contact us at - 10,000 transcription requests submitted every 10 minutes - 500 transcriptions processed every 10 minutes - Multi-part/form-data requests to the /jobs endpoint have a concurrency limit of 10 and a file size limit of 2GB - POST requests to the /jobs endpoint that use the media_url property do not have a concurrency limit or file restriction. They are only limited by the first two bullet points # Error Handling The API indicates failure with 4xx and 5xx HTTP status codes. 4xx status codes indicate an error due to the request provided (e.g., a required parameter was omitted). 5xx error indicate an error with Rev.ai's servers. When an 4xx error occurs during invocation of a request, the API responds with a [problem details](https://tools.ietf.org/html/rfc7807) as HTTP response payload. The problem details information is represented as a JSON object with the following optional properties: | Property | Description | |------------|-----------------------------------------------| | type | a URI representing the type for the error | | title | a short human readable description of type | | details | additional details of the error | | status | HTTP status code of the error | In addition to the properties listed above, the problem details object may list additional properties that help to troubleshoot the problem. ## Example Errors ``` // Bad Submit Job Request { "parameter": { "media_url": [ "The media_url field is required" ] }, "type": "https://www.rev.ai/api/v1/errors/invalid-parameters", "title": "Your request parameters didn't validate", "status": 400 } // Invalid Transcript State { "allowed_values": [ "transcribed" ], "current_value": "in_progress", "type": "https://rev.ai/api/v1/errors/invalid-job-state", "title": "Job is in invalid state", "detail": "Job is in invalid state to obtain the transcript", "status": 409 } ``` ## Retrying Failed Requests Some errors can be resolved simply by retrying the request. The following error codes are likely to be resolved with successive retries. | Status Code | Error | |---|:---| | 429 | Too Many Requests | | 502 | Bad Gateway | | 503 | Service Unavailable | | 504 | Gateway Timeout | Note: With the exception of the 429 status code, it is recommended that the maximum number of retries be limited to 5 attempts per request. The number of retries can be higher for 429 errors but if you notice consistent throttling please contact us at .

reverb

Test our API services using I/O Docs.

Import your orders, retrieve your orders and generate labels.

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 ```

Manage Runscope programmatically.

# Introduction Welcome to the documentation for the Sakari Messaging REST API. Sakari provides an advanced platform to drive large scale customized SMS communication REST is a web-service protocol that lends itself to rapid development by using everyday HTTP and JSON technology. To find out more about our product offering, please visit [https://sakari.io](https://sakari.io). # Quickstart For your convenience we have created a quickstart guide to get you up and running in 5 minutes. [https://sakari.io/blog/sakari-api-quickstart](https://sakari.io/blog/sakari-api-quickstart) # PostMan Collection We've created a simple set of examples using [PostMan](https://www.getpostman.com/) Simply click below to import these. You will need to setup three environment variables in PostMan - AccountId, ClientId and ClientSecret. Check out our PostMan blog post for more information [](https://app.getpostman.com/run-collection/d616e273edc916a7a6eb) # Finding your client id, client secret and account id To authenticate against the API's you will need three key pieces of data - client id - client secret - account id To retrieve these, simply login into [https://hub.sakari.io](https://hub.sakari.io) and click on the "cog" in the top right corner. In the popup dialog at the bottom you should see your API credentials and account id. If these are not visible you will need to click on "Request Credentials" # Versioning With any breaking changes we will introduce a new version of the API. The latest version is v1. The API uses an open schema model, which means server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break. # Testing There are numerous tools available for testing the API's. We will include examples using curl and the client SDKs that we have created. If you would like to see an SDK in a language not currently available, please let us know. # Throttling / Limits Our API's have been specifically designed to support bulk messaging in a single API call. We therefore impose limits on the frequency of calling the APIs to prevent abuse or runaway processes. If you feel you need a higher limit, please contact us. If you hit the limit you will get a 429 error code returned from our servers # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { "success": false, "error": { "code": "CONT-001", "message": "Invalid mobile number" } } ``` # Pagination For performance, most GET calls return a subset of data. This data is paginated for easy access. Most APIs which return collections of data will return a pagination object as such: ``` { "pagination": { "offset": 0, "limit": 10 "totalCount": 21 } } ``` When making calls to the API, you can adjust the slice of data returned using query parameters such as: `` https://api.sakari.io/v1/accounts/123/contacts?offset=20&limit=25 `` This will return 25 contacts with an offset of 20.

Provided by [Salesforce](https://www.einstein-hub.com/) � Copyright 2000�2020 salesforce.com, inc. All rights reserved. Salesforce is a registered trademark of salesforce.com, inc., as are other names and marks. Other marks appearing herein may be trademarks of their respective owners. **Last updated:** Aug 17, 2020