Heuristic TTL for HTTP-Cache Headers
ONLY Checks for X-FRAME_OPTIONS in HTTP HEADERS
A simple class that takes an HTTP Basic Auth header value and decodes it into a user_id and password
The Nodeum API makes it easy to tap into the digital data mesh that runs across your organisation. Make requests to our API endpoints and we’ll give you everything you need to interconnect your business workflows with your storage. All production API requests are made to: http://nodeumhostname/api/ The current production version of the API is v1. **REST** The Nodeum API is a RESTful API. This means that the API is designed to allow you to get, create, update, & delete objects with the HTTP verbs GET, POST, PUT, PATCH, & DELETE. **JSON** The Nodeum API speaks exclusively in JSON. This means that you should always set the Content-Type header to application/json to ensure that your requests are properly accepted and processed by the API. **Authentication** All API calls require user-password authentication. **Cross-Origin Resource Sharing** The Nodeum API supports CORS for communicating from Javascript for these endpoints. You will need to specify an Origin URI when creating your application to allow for CORS to be whitelisted for your domain. **Pagination** Some endpoints such as File Listing return a potentially lengthy array of objects. In order to keep the response sizes manageable the API will take advantage of pagination. Pagination is a mechanism for returning a subset of the results for a request and allowing for subsequent requests to “page” through the rest of the results until the end is reached. Paginated endpoints follow a standard interface that accepts two query parameters, limit and offset, and return a payload that follows a standard form. These parameters names and their behavior are borrowed from SQL LIMIT and OFFSET keywords. **Versioning** The Nodeum API is constantly being worked on to add features, make improvements, and fix bugs. This means that you should expect changes to be introduced and documented. However, there are some changes or additions that are considered backwards-compatible and your applications should be flexible enough to handle them. These include: - Adding new endpoints to the API - Adding new attributes to the response of an existing endpoint - Changing the order of attributes of responses (JSON by definition is an object of unordered key/value pairs) **Filter parameters** When browsing a list of items, multiple filter parameters may be applied. Some operators can be added to the value as a prefix: - `=` value is equal. Default operator, may be omitted - `!=` value is different - `>` greater than - `>=` greater than or equal - `<` lower than - `>=` lower than or equal - `><` included in list, items should be separated by `|` - `!><` not included in list, items should be separated by `|` - `~` pattern matching, may include `%` (any characters) and `_` (one character) - `!~` pattern not matching, may include `%` (any characters) and `_` (one character)
Rack middleware that measures HTTP request queue duration from upstream headers and reports it to Yabeda as a histogram metric.
SimpleHttpService is a simple Ruby library to make HTTP requests with customizable options for headers, timeouts, and retries. It provides a convenient way to create and send HTTP requests using a clean and simple interface.
Helpers for setting the HTTP Vary header in Sinatra.
Rack middleware to strip accept headers from non XHR requests
Useful HTTP Header
The Tripletex API is a **RESTful API**, which does not implement PATCH, but uses a PUT with optional fields. **Actions** or commands are represented in our RESTful path with a prefixed `:`. Example: `/v2/hours/123/:approve`. **Summaries** or aggregated results are represented in our RESTful path with a prefixed <code>></code>. Example: <code>/v2/hours/>thisWeeksBillables</code>. **"requestID"** is a key found in all validation and error responses. If additional log information is absolutely necessary, our support division can locate the key value. **Download** the [swagger.json](/v2/swagger.json) file [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification) to [generate code](https://github.com/sveredyuk/tripletex_ruby). This document was generated from the Swagger JSON file. **version:** This is a versioning number found on all DB records. If included, it will prevent your PUT/POST from overriding any updates to the record since your GET. **Date & DateTime** follows the **ISO 8601** standard. Date: `YYYY-MM-DD`. DateTime: `YYYY-MM-DDThh:mm:ssZ` **Sorting** is done by specifying a comma separated list, where a `-` prefix denotes descending. You can sort by sub object with the following format: `project.name, -date`. **Searching:** is done by entering values in the optional fields for each API call. The values fall into the following categories: range, in, exact and like. **Missing fields or even no response data** can occur because result objects and fields are filtered on authorization. **See [FAQ](https://tripletex.no/execute/docViewer?articleId=906&language=0) for more additional information.** ## Authentication: - **Tokens:** The Tripletex API uses 3 different tokens - **consumerToken**, **employeeToken** and **sessionToken**. - **consumerToken** is a token provided to the consumer by Tripletex after the API 2.0 registration is completed. - **employeeToken** is a token created by an administrator in your Tripletex account via the user settings and the tab "API access". Each employee token must be given a set of entitlements. [Read more here.](https://tripletex.no/execute/docViewer?articleId=853&language=0) - **sessionToken** is the token from `/token/session/:create` which requires a consumerToken and an employeeToken created with the same consumer token, but not an authentication header. See how to create a sessionToken [here](https://tripletex.no/execute/docViewer?articleId=855&language=0). - The session token is used as the password in "Basic Authentication Header" for API calls. - Use blank or `0` as username for accessing the account with regular employee token, or if a company owned employee token accesses <code>/company/>withLoginAccess</code> or <code>/token/session/>whoAmI</code>. - For company owned employee tokens (accounting offices) the ID from <code>/company/>withLoginAccess</code> can be used as username for accessing client accounts. - If you need to create the header yourself use <code>Authorization: Basic <base64encode('0:sessionToken')></code>. ## Tags: - <div class="tag-icon-beta"></div> **[BETA]** This is a beta endpoint and can be subject to change. - <div class="tag-icon-deprecated"></div> **[DEPRECATED]** Deprecated means that we intend to remove/change this feature or capability in a future "major" API release. We therefore discourage all use of this feature/capability. ## Fields: Use the `fields` parameter to specify which fields should be returned. This also supports fields from sub elements. Example values: - `project,activity,hours` returns `{project:..., activity:...., hours:...}`. - just `project` returns `"project" : { "id": 12345, "url": "tripletex.no/v2/projects/12345" }`. - `project(*)` returns `"project" : { "id": 12345 "name":"ProjectName" "number.....startDate": "2013-01-07" }`. - `project(name)` returns `"project" : { "name":"ProjectName" }`. - All elements and some subElements : `*,activity(name),employee(*)`. ## Changes: To get the changes for a resource, `changes` have to be explicitly specified as part of the `fields` parameter, e.g. `*,changes`. There are currently two types of change available: - `CREATE` for when the resource was created - `UPDATE` for when the resource was updated NOTE: For objects created prior to October 24th 2018 the list may be incomplete, but will always contain the CREATE and the last change (if the object has been changed after creation). ## Rate limiting in each response header: Rate limiting is performed on the API calls for an employee for each API consumer. Status regarding the rate limit is returned as headers: - `X-Rate-Limit-Limit` - The number of allowed requests in the current period. - `X-Rate-Limit-Remaining` - The number of remaining requests. - `X-Rate-Limit-Reset` - The number of seconds left in the current period. Once the rate limit is hit, all requests will return HTTP status code `429` for the remainder of the current period. ## Response envelope: ``` { "fullResultSize": ###, "from": ###, // Paging starting from "count": ###, // Paging count "versionDigest": "Hash of full result", "values": [...list of objects...] } { "value": {...single object...} } ``` ## WebHook envelope: ``` { "subscriptionId": ###, "event": "object.verb", // As listed from /v2/event/ "id": ###, // Object id "value": {... single object, null if object.deleted ...} } ``` ## Error/warning envelope: ``` { "status": ###, // HTTP status code "code": #####, // internal status code of event "message": "Basic feedback message in your language", "link": "Link to doc", "developerMessage": "More technical message", "validationMessages": [ // Will be null if Error { "field": "Name of field", "message": "Validation failure information" } ], "requestId": "UUID used in any logs" } ``` ## Status codes / Error codes: - **200 OK** - **201 Created** - From POSTs that create something new. - **204 No Content** - When there is no answer, ex: "/:anAction" or DELETE. - **400 Bad request** - - **4000** Bad Request Exception - **11000** Illegal Filter Exception - **12000** Path Param Exception - **24000** Cryptography Exception - **401 Unauthorized** - When authentication is required and has failed or has not yet been provided - **3000** Authentication Exception - **9000** Security Exception - **403 Forbidden** - When AuthorisationManager says no. - **404 Not Found** - For content/IDs that does not exist. - **6000** Not Found Exception - **409 Conflict** - Such as an edit conflict between multiple simultaneous updates - **7000** Object Exists Exception - **8000** Revision Exception - **10000** Locked Exception - **14000** Duplicate entry - **422 Bad Request** - For Required fields or things like malformed payload. - **15000** Value Validation Exception - **16000** Mapping Exception - **17000** Sorting Exception - **18000** Validation Exception - **21000** Param Exception - **22000** Invalid JSON Exception - **23000** Result Set Too Large Exception - **429 Too Many Requests** - Request rate limit hit - **500 Internal Error** - Unexpected condition was encountered and no more specific message is suitable - **1000** Exception
Ignore google indexing with http headers
Just use Rack::HTTPCat in your application for all requests to have a link to the https://http.cat for their status under the HTTP-Cat header.
The HttpRecognizer receives streamed HTTP, and when it accumulates enough to identify that it's seen an HTTP header, it attempts to extract some basic information from it. This is not a parser, and it is woefully incomplete, but for many tasks it understands just enough HTTP to be useful.
GlobalRequestId is a rails gem that makes your correlation id (X-REQUEST-ID header) globally avaiable during your entire http request.
Connect brokerage accounts to your app for live positions and trading. ## Rate limiting Two limits apply to requests signed with your `clientId`. The stricter one wins, and exceeding either returns `429 Too Many Requests`. - **Customer-level** — 250 requests/minute by default, scoped to your `clientId` and applied across all endpoints. Reported in `X-RateLimit-Limit`, `X-RateLimit-Remaining` and `X-RateLimit-Reset`. - **Account-level** — 10 requests/minute per account, scoped to (`clientId`, `accountId`). All covered operations for one account draw on the same bucket — reading balances and reading positions share it — and enforcement does not depend on the HTTP method, so updating an account consumes the same bucket as reading it. Only enforced for Personal users, and only for integrations it has been rolled out to — it is not yet in force for every Personal integration. It also does not apply on every operation that documents a 429 below. Where it applies it is reported in `X-RateLimit-Account-Limit`, `X-RateLimit-Account-Remaining` and `X-RateLimit-Account-Reset`. Do not read the absence of those headers as proof the limit is off — some configurations omit the rate limit headers while still enforcing the limit, so header absence tells you nothing about your allowance. On a 429, `X-RateLimit-Remaining: 0` means you hit the customer-level limit and `X-RateLimit-Account-Remaining: 0` means the account-level one. Wait for the corresponding `*-Reset` value (seconds) before retrying, or fall back to exponential backoff with jitter. Not every 429 is explained by those headers. A separate per-authenticated-user limit, reported in no `X-RateLimit-*` header, covers OAuth-authenticated requests and signed requests in configurations where the customer-level limit is not in effect — on the operations that use the default throttles. A few operations override those and are governed by the customer-level limit alone. The two do not stack: a signed request governed by the customer-level limit above is not additionally subject to the per-user one. If a 429 arrives with no header at zero — or with no `X-RateLimit-*` headers at all — honour `Retry-After` and back off. Treat the remaining counts as a hint, not a guarantee that the next request will succeed. Because the customer-level limit applies everywhere, any signed request can return 429. **OAuth-authenticated requests are an exception.** They are not subject to the customer-level limit and do not receive `X-RateLimit-Limit`, `X-RateLimit-Remaining` or `X-RateLimit-Reset` — do not wait on those headers or design around a customer-level allowance on this path. The account-level limit still applies to them on the account-data endpoints above, reported in the `X-RateLimit-Account-*` headers. On operations using the default throttles the per-user limit above applies to them as well, so an OAuth request can be rejected while the account headers still show capacity; on the few operations that override those throttles, OAuth callers have no per-user ceiling at all. Drive retries from `Retry-After` and exponential backoff with jitter rather than from the headers. See https://docs.snaptrade.com/docs/ratelimiting.
A Simple Gem to handle HTTP Headers you sent and the server responses. Uses Socket Lib for connecting more faster.
Secure HTTP headers for Cuba
Simplifies creating a content security policy for use as an HTTP header
# Rack HTTP Pipe Use to pipe directly a remote HTTP file without buffering it. > /!\ Do not work with WebBrick, tested with puma ## Use case * Given a file named #HASH#.pdf on S3 * You want a clean URL and handling the authentication in front of it ``` GET http:/example.com/download Content-Disposition: attachment;filename=name-fetched-from-db.pdf Content-Length Content-Type etc. ``` ## Usage ```ruby get "/" do http_pipe "http://example.com/iso-ubuntu-1404-64bits", { status: 200, headers: { "Content-Type: application/octet-stream", "Content-Disposition: attachment;filename=ubuntu.iso", } } end ``` See the example directory for an example app using sinatra
HTTP Status Code Lookup decodes any HTTP status code by returning its standard name and detailed description. Provide a numeric code to inspect its meaning and response behavior across standard ranges, and add details=true for a link to the defining RFC section, plus on paid plans its retry and caching behavior and the headers that go with it.
== Content-hash cache busting for Jekyll A zero-config plugin that content-tags supported local asset URLs in generated .html/.htm attributes at post_write — covering markup emitted by themes and plugins without template changes. CSS/JS runtime references and HTTP cache headers are outside its scope.
# 1MSG Ruby SDK Official Ruby SDK for the **1MSG WhatsApp Business API**. This document is generated from the public OpenAPI contract. It covers install, auth, quick start, and every public operation available in the client. | | | |---|---| | **RubyGems** | [`one_msg_sdk`](https://rubygems.org/gems/one_msg_sdk) | | **Source** | [github.com/1msg/1msg-sdk/ruby](https://github.com/1msg/1msg-sdk/tree/main/ruby) | | **API docs** | [docs.1msg.io](https://docs.1msg.io/) | | **Platform** | [platform.1msg.io](https://platform.1msg.io/) | | **Support** | support@1msg.io | | **OpenAPI version** | 1.0.0 | | **Operations** | 60 | | **AI agent guide** | [AGENTS.md](./AGENTS.md) | --- ## Install ```bash gem install one_msg_sdk -v 2.0.2 ``` ## Requirements | Variable | Where to get it | Example | |----------|-----------------|---------| | `baseUrl` | Platform → channel → API host | `https://api.1msg.io` | | `instanceId` | Platform → channel id | `ODI371267300` | | `token` | Platform → channel → API token | JWT or API key | Use environment variables (`MSG_API_TOKEN`, `MSG_INSTANCE_ID`). Never commit tokens. ## Quick start ```ruby require 'one_msg_sdk' OneMsgSdk.configure do |config| config.host = "https://api.1msg.io/#{ENV.fetch('MSG_INSTANCE_ID')}" end messaging = OneMsgSdk::MessagingApi.new messaging.send_message( ENV.fetch('MSG_API_TOKEN'), 'Hello from 1MSG SDK', nil, '12020721369@c.us' ) ``` ## Authentication All requests use query-token auth: ```text https://{baseUrl}/{instanceId}/{path}?token={token} ``` Pass the channel token as the first argument to generated API methods. ## Recipient addressing - `chatId`: `12020721369@c.us` (1:1) or `...@g.us` (group) - `phone`: country code + number, no `+` - Exactly one of `chatId` | `phone` per request ## 24-hour messaging window Free-form `sendMessage` only works inside the 24h customer-care window. Outside that window use `sendTemplate`. ## Client map ```ruby MessagingApi # send/list messages, media, interactive ProfileApi # getMe GroupsApi # create/list/manage groups FlowsApi # WhatsApp Flows lifecycle TemplatesApi # listTemplates ChannelApi # channel helpers CallingApi # calling WebhooksApi # webhooks ``` ## Package notes Gem name is `one_msg_sdk`. Module is `OneMsgSdk`. ## API reference API groups: calling, catalog, channel, flows, groups, messaging, profile, templates, users, webhooks. ### calling #### `getCallingSettings` Get calling settings Return WhatsApp Calling API settings for this channel (beta). Proxies upstream `GET /calling/settings`. **Prerequisites** - Number must be eligible for Meta Calling (Cloud API; not COEX) - Trial / `subscriptionBlocked` channels receive **403** plain text - You need your own WebRTC or SIP stack; 1msg is a **signaling proxy** only and does **not** store call history or recordings See the **Calling** tag overview for inbound/outbound flows and webhooks. ```yaml http: GET /callingSettings operationId: getCallingSettings clientGroup: calling responses: 200, 401, 500 ``` #### `initiateCall` Call action (connect / pre_accept / accept / reject / terminate) Perform a WhatsApp Calling action (beta). Proxies upstream `POST /calling/calls`. Despite the historical path name `/initiateCall`, this endpoint handles **all** call actions: | action | Use | Required | |--------|-----|----------| | `connect` | Outbound business → user | `to` + `session` (`sdp_type: offer`) | | `pre_accept` | Inbound (optional, reduces audio clipping) | `call_id` + `session` (`sdp_type: answer`) | | `accept` | Inbound answer | `call_id` + `session` (`sdp_type: answer`) | | `reject` | Decline inbound | `call_id` | | `terminate` | Hang up | `call_id` | **SDP / media (critical)** - `accept` / `pre_accept` require a **WebRTC-generated SDP answer**. - Do **not** send Meta's offer SDP back as the answer. - Postman (or curl) alone **cannot** establish real media — you need a WebRTC or SIP stack. 1msg only proxies signaling. Answer within ~**30–60 seconds** of an inbound `connect` webhook or Meta terminates as unanswered. Common Meta errors include Calling not enabled (`138000`), no permission (`138006`), SDP validation failures. **Outbound** requires a prior Call Permission Request (CPR) acceptance. See the **Calling** tag overview for the full outbound flow and CPR limits. Trial / `subscriptionBlocked` → **403** plain text. Upstream failures often return HTTP 200 with `{ "response": { "error": "..." } }`. ```yaml http: POST /initiateCall operationId: initiateCall clientGroup: calling responses: 200, 401, 500 ``` #### `updateCallingSettings` Update calling settings Enable, disable, or update WhatsApp Calling settings (beta). Proxies upstream `POST /calling/settings`. Body is forwarded as-is (1msg does not validate fields). **Common fields under `calling`** - `status` (`ENABLED` | `DISABLED`) — required to turn calling on/off - `call_icon_visibility` (`DEFAULT` | `DISABLE_ALL`) — optional - `callback_permission_status` (`ENABLED` | `DISABLED`) — optional; when enabled, inbound user calls grant callback permission - `call_hours` — optional hours / timezone object - `sip` — optional SIP trunk; when SIP is ENABLED, Graph call actions and calling webhooks are not used - `srtp_key_exchange_protocol` (`DTLS` | `SDES`) — SDES only with SIP - `video.status` — optional Meta may accept only one feature group per request — prefer focused updates (e.g. enable status first, then SIP). Trial / `subscriptionBlocked` → **403** plain text. ```yaml http: POST /callingSettings operationId: updateCallingSettings clientGroup: calling responses: 200, 401, 500 ``` ### catalog #### `createCommerce` Set Commerce Settings Update catalog/cart commerce settings via the `params` object. - `params.is_catalog_visible` — show catalog storefront icon (`true`) or hide it (`false`). - `params.is_cart_enabled` — enable cart (`true`) or disable it (`false`). Blocked when the channel subscription limit is exceeded. Requires a commerce-capable channel (Cloud Functions `/commerceWAV2`). ```yaml http: POST /commerce operationId: createCommerce clientGroup: catalog responses: 200, 401, 500 ``` #### `getCommerce` Get Commerce Settings Returns catalog/cart commerce settings for the channel. - `is_catalog_visible` — show catalog storefront icon (`true`) or hide it (`false`). - `is_cart_enabled` — enable cart (`true`) or disable it (`false`). ```yaml http: GET /commerce operationId: getCommerce clientGroup: catalog responses: 200, 401, 500 ``` ### channel #### `getConversationalAutomation` Get conversational automation settings Get WhatsApp conversational components for the channel (welcome message, ice-breaker prompts, and slash commands). Proxies Meta/360dialog `GET /conversational_automation`. When `enable_welcome_message` is true and a user opens chat for the first time, Meta delivers a webhook message with `type: request_welcome`. The inbound formatter exposes that as `type: "request_welcome"` and `meta.request_welcome: true` so your webhook can send a custom welcome reply. ```yaml http: GET /conversationalAutomation operationId: getConversationalAutomation clientGroup: channel responses: 200, 401, 500 ``` #### `getStatus` Get channel status Returns WhatsApp Business API client connection status. ```yaml http: GET /status operationId: getStatus clientGroup: channel responses: 200, 401, 500 ``` #### `setConversationalAutomation` Set conversational automation settings Update WhatsApp conversational components. Allowed body fields (others are ignored): - `enable_welcome_message` (boolean) - `prompts` (string[], max 4, each ≤ 80 chars) - `commands` (`{ command_name, command_description }[]`) Proxies Meta/360dialog `POST /conversational_automation`. ```yaml http: POST /conversationalAutomation operationId: setConversationalAutomation clientGroup: channel responses: 200, 401, 500 ``` ### flows #### `createFlows` Create Flow ```yaml http: POST /flows operationId: createFlows clientGroup: flows responses: 200 ``` #### `createFlowsFlowIdDeprecate` Deprecate Flow ```yaml http: POST /flows/{flowId}/deprecate operationId: createFlowsFlowIdDeprecate clientGroup: flows responses: 200 ``` #### `createFlowsFlowIdPublish` Publish Flow ```yaml http: POST /flows/{flowId}/publish operationId: createFlowsFlowIdPublish clientGroup: flows responses: 200 ``` #### `deleteFlowsFlowId` Delete Flow ```yaml http: DELETE /flows/{flowId} operationId: deleteFlowsFlowId clientGroup: flows responses: 200 ``` #### `getFlowsFlowId` Get Flow Details ```yaml http: GET /flows/{flowId} operationId: getFlowsFlowId clientGroup: flows responses: 200 ``` #### `getFlowsFlowIdPreview` Preview Flow ```yaml http: GET /flows/{flowId}/preview operationId: getFlowsFlowIdPreview clientGroup: flows responses: 200 ``` #### `getWhatsappBusinessEncryption` Get business encryption public key Retrieve the WhatsApp business public key and signature status for this channel's phone number. Required before publishing or sending Flows that use data encryption. ```yaml http: GET /whatsapp_business_encryption operationId: getWhatsappBusinessEncryption clientGroup: flows responses: 200, 401, 500 ``` #### `listFlows` List Flows ```yaml http: GET /flows operationId: listFlows clientGroup: flows responses: 200 ``` #### `patchFlowsFlowIdAssets` Update Flow Structure ```yaml http: PATCH /flows/{flowId}/assets operationId: patchFlowsFlowIdAssets clientGroup: flows responses: 200 ``` #### `patchFlowsFlowIdMetadata` Update Flow Metadata ```yaml http: PATCH /flows/{flowId}/metadata operationId: patchFlowsFlowIdMetadata clientGroup: flows responses: 200 ``` #### `setWhatsappBusinessEncryption` Set business encryption public key Upload and sign a 2048-bit RSA business public key (PEM) for this channel's phone number. Meta requires a signed key before Flow publish/send. Only one active key per number; a new upload replaces the previous key. ```yaml http: POST /whatsapp_business_encryption operationId: setWhatsappBusinessEncryption clientGroup: flows responses: 200, 400, 401, 500 ``` ### groups #### `createGroups` Create Group ```yaml http: POST /groups operationId: createGroups clientGroup: groups responses: 200 ``` #### `createGroupsGroupId` Update Group Info ```yaml http: POST /groups/{groupId} operationId: createGroupsGroupId clientGroup: groups responses: 200 ``` #### `createGroupsGroupIdInvitelink` Reset Invite Link ```yaml http: POST /groups/{groupId}/inviteLink operationId: createGroupsGroupIdInvitelink clientGroup: groups responses: 200 ``` #### `deleteGroupsGroupId` Delete Group ```yaml http: DELETE /groups/{groupId} operationId: deleteGroupsGroupId clientGroup: groups responses: 200 ``` #### `getGroupsGroupId` Get Group Info ```yaml http: GET /groups/{groupId} operationId: getGroupsGroupId clientGroup: groups responses: 200 ``` #### `getGroupsGroupIdInvitelink` Get Invite Link ```yaml http: GET /groups/{groupId}/inviteLink operationId: getGroupsGroupIdInvitelink clientGroup: groups responses: 200 ``` #### `listGroups` Get Groups List ```yaml http: GET /groups operationId: listGroups clientGroup: groups responses: 200 ``` ### messaging #### `createReadMessage` Mark message as read ```yaml http: POST /readMessage operationId: createReadMessage clientGroup: messaging responses: 200, 401 ``` #### `createUploadMedia` Upload media ```yaml http: POST /uploadMedia operationId: createUploadMedia clientGroup: messaging responses: 200 ``` #### `deleteMedia` Delete media from WABA storage Delete previously uploaded media by numeric `mediaId` (from `/uploadMedia`). This is the canonical deletion endpoint and uses the REST `DELETE` verb on the media resource path. The older `POST /deleteMedia` is a deprecated alias. ```yaml http: DELETE /media/{mediaId} operationId: deleteMedia clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `deleteMediaLegacy` Delete media from WABA storage (deprecated alias) **Deprecated.** Use `DELETE /media/{mediaId}` instead. This POST alias is kept for backward compatibility with earlier integrations. New integrations should call `DELETE /media/{mediaId}`: 1msg follows REST conventions for resource deletion going forward (delete a resource with the `DELETE` verb on its resource path). ```yaml http: POST /deleteMedia operationId: deleteMediaLegacy clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `getMmLiteStatus` Get MM Lite availability and status ```yaml http: GET /mmLiteStatus operationId: getMmLiteStatus clientGroup: messaging responses: 200, 401, 500 ``` #### `listMessages` Get messages list ```yaml http: GET /messages operationId: listMessages clientGroup: messaging responses: 200 ``` #### `retrieveMedia` Retrieve uploaded media metadata Get WABA media URL and metadata by mediaId (from uploadMedia). The returned `url` is temporary and typically expires within ~5 minutes. ```yaml http: GET /retrieveMedia operationId: retrieveMedia clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendAddressMessage` Send address request message Request shipping address from the user (WhatsApp interactive `address_message`). **India and Singapore only.** Requires: - Business WhatsApp number registered in that country - Recipient phone matching the country (`+91` ↔ `IN`, `+65` ↔ `SG`) Pass `country: "IN"` or `country: "SG"`. Eligibility is validated upstream; mismatches (e.g. Singapore phone with `country: "IN"`) return errors such as `Unsupported Interactive Message type` (HTTP 200 with `sent: false`). Optional action parameters: `values`, `saved_addresses`, `validation_errors`. ```yaml http: POST /sendAddressMessage operationId: sendAddressMessage clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendButton` Send Reply Buttons Message ```yaml http: POST /sendButton operationId: sendButton clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendCarousel` Send Carousel You can send product cards via Carousel in two ways: Template messages: do not require a 24-hour customer service window between you and the recipient. Use sendTemplate. Free-form messages: can be sent only when a customer service window is open between you and the recipient. Use sendCarousel. The message structure in /sendCarousel is largely similar to sending a template. However, in this case you must explicitly specify all elements that are created in advance when working with templates. This is because the message is sent without using a template. In /sendCarousel, for sending a Catalog Carousel there can be either 1 URL button or one or more quick reply buttons. ```yaml http: POST /sendCarousel operationId: sendCarousel clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendContact` Send a Contact ```yaml http: POST /sendContact operationId: sendContact clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendCtaUrl` Send CTA URL interactive message Send an interactive message with a single call-to-action URL button. ```yaml http: POST /sendCtaUrl operationId: sendCtaUrl clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendFile` Send a File Send a file to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendFile operationId: sendFile clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendFlow` Send WhatsApp Flow Message Send Interactive WhatsApp Flow message to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. Use this method to send a published WhatsApp Flow as a service (interactive) message. If the 24-hour window is closed, send a template with a FLOW button via /sendTemplate. ```yaml http: POST /sendFlow operationId: sendFlow clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendList` Send List Message ```yaml http: POST /sendList operationId: sendList clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendLocation` Send a Location Send a location to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendLocation operationId: sendLocation clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendLocationRequest` Send Location Request Message ```yaml http: POST /sendLocationRequest operationId: sendLocationRequest clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendMessage` Send a Message Send a message to an existing chat. (Only if the dialogue has an Open Session). The message will be added to the queue for sending and delivered even if the phone is disconnected from the Internet or authorization is not passed. Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendMessage operationId: sendMessage clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendOrderDetails` Send order details (India payments template) Send a WhatsApp **order details** payment / invoice message using a pre-approved **Utility** template that has an `ORDER_DETAILS` button. **India only** (WhatsApp Payments India). Requires: - India WhatsApp Business number - Commerce enabled on the channel (`GET`/`POST /commerce`) - Approved template with an `ORDER_DETAILS` button Use this method when you need structured fields (`order`, `referenceId`, `currency`, `paymentSettings`). The API appends a template button `sub_type: order_details` and sends via the same path as `POST /sendTemplate`. Works **outside the 24-hour session window** (template message). You can also send the same payload yourself with `POST /sendTemplate` by including a button component in `params`: ```json { "type": "button", "sub_type": "order_details", "index": 0, "parameters": [{ "type": "action", "action": { "order_details": { "reference_id": "order-123", "currency": "INR", "order": { "status": "pending", "items": [], "subtotal": { "offset": 100, "value": 50000 } } } } }] } ``` ```yaml http: POST /sendOrderDetails operationId: sendOrderDetails clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendPaymentRequest` Send payment request (regional) Send a regional payment request interactive message (beta scaffold). `region` must be IN, SG, or BR. Payload shape follows Meta regional payments docs; verify on stage before production use. Full regional builders are not implemented yet. ```yaml http: POST /sendPaymentRequest operationId: sendPaymentRequest clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendProduct` Send a Product ```yaml http: POST /sendProduct operationId: sendProduct clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendReaction` Send Reaction ```yaml http: POST /sendReaction operationId: sendReaction clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendSticker` Send sticker message Send a WhatsApp sticker by mediaId or link URL. ```yaml http: POST /sendSticker operationId: sendSticker clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` ### profile #### `getMe` Get Profile Info Get WhatsApp Business Account profile information ```yaml http: GET /me operationId: getMe clientGroup: profile responses: 200, 401, 500 ``` #### `updateMe` Update profile info Update WhatsApp Business Account profile fields. At least one of about, description, email, photo, address, vertical, websites is required. Blocked when the channel subscription limit is exceeded. ```yaml http: POST /me operationId: updateMe clientGroup: profile responses: 200, 401, 422, 500 ``` ### templates #### `addTemplate` Create message template ```yaml http: POST /addTemplate operationId: addTemplate clientGroup: templates responses: 200, 401, 500 ``` #### `listTemplates` Get templates list ```yaml http: GET /templates operationId: listTemplates clientGroup: templates responses: 200 ``` #### `removeTemplate` Remove message template ```yaml http: POST /removeTemplate operationId: removeTemplate clientGroup: templates responses: 200, 401, 500 ``` #### `sendTemplate` Send Template Message Send a WhatsApp template message (works outside the 24-hour session window). Supported `params` button `sub_type` values include: `url`, `quick_reply`, `copy_code` / `coupon_code`, `catalog`, `flow`, `limited_time_offer`, and **`order_details`** (WhatsApp Payments **India only** — requires an approved Utility template with an ORDER_DETAILS button). For India order/invoice payments outside 24h, include a button component: ```json { "type": "button", "sub_type": "order_details", "index": 0, "parameters": [{ "type": "action", "action": { "order_details": { "reference_id": "...", "currency": "INR", "order": {} } } }] } ``` Convenience wrapper with structured fields: `POST /sendOrderDetails`. ```yaml http: POST /sendTemplate operationId: sendTemplate clientGroup: templates responses: 200 ``` ### users #### `blockUser` Block WhatsApp user ```yaml http: POST /blockUser operationId: blockUser clientGroup: users responses: 200, 400, 401, 500 ``` #### `listBlockedUsers` List blocked WhatsApp users Returns users currently blocked on this WhatsApp channel (WABA `GET /block_users`). Same channel token auth as `blockUser` / `unblockUser`. ```yaml http: GET /blockedUsers operationId: listBlockedUsers clientGroup: users responses: 200, 401, 500 ``` #### `unblockUser` Unblock WhatsApp user ```yaml http: POST /unblockUser operationId: unblockUser clientGroup: users responses: 200, 400, 401, 500 ``` ### webhooks #### `getWebhook` Get webhook URL Returns the configured client webhook URL for this channel. ```yaml http: GET /webhook operationId: getWebhook clientGroup: webhooks responses: 200, 401, 500 ``` #### `setWebhook` Set webhook URL Configure the client webhook URL for inbound events. WhatsApp **Calling** events (`field=calls`) are forwarded as passthrough payloads with `type: "calls"` and `instanceId` (connect / status / terminate). Call permission replies arrive on the normal messages path (`call_permission_reply`). Details: **Calling** tag. ```yaml http: POST /webhook operationId: setWebhook clientGroup: webhooks responses: 200, 401, 500 ``` ## Cookbook 1. Install the package from the registry above. 2. Set `MSG_API_TOKEN` and `MSG_INSTANCE_ID`. 3. Create the messaging client with `{baseUrl}/{instanceId}`. 4. Call `sendMessage` inside the 24h window, or `sendTemplate` outside it. 5. Use group/profile/flows/templates APIs for advanced workflows. ## FAQ **Where is the package?** See the registry link in the header table. **TypeScript has createClient — does this SDK?** Generated OpenAPI clients use per-API classes (`MessagingApi`, `ProfileApi`, …) instead of a facade. **Can I use this in a browser?** No — server-side only. Never expose tokens. ## Error handling | Code | Meaning | |------|---------| | 400 | Invalid parameters or body | | 401 | Invalid or missing token | | 429 | Rate limit exceeded | | 500 | Internal server error | ## Regeneration and versioning Docs regenerate with `node gen/generate-sdk-docs-langs.js`. Registry versions are immutable. ## License MIT © 1MSG
The **Norbelys API** is a single, predictable REST surface for cold email and outreach — people, senders, programs, and sending all live behind the five patterns below. Developer-first and AI-first: every name is either already invented (Schema.org) or obvious. ## Authentication Every request authenticates with an **org-scoped API key**. Create one in **Settings → API keys** and send it as a bearer token: ```http GET https://api.norbelys.com/v1/people Authorization: Bearer ak_live_… ``` Interactive agents may instead use OAuth 2.1 (see `/auth.md` and the `/.well-known/oauth-protected-resource` metadata). ## Conventions - **Base URL** — `https://api.norbelys.com/v1`. - **JSON in, JSON out.** Timestamps are ISO-8601 in UTC. - **Cursor pagination.** List endpoints take `limit` + `cursor` and return `{ data, hasMore, nextCursor }` (offset-paged tables add `page` + `total`). - **Expansions.** Detail GETs take an `expand[]` query param to inline related data (e.g. `GET /people/{id}?expand[]=timeline`) instead of extra calls. - **Soft deletes.** Anything that has been used is archived, never hard-deleted — `DELETE` archives the resource and returns it. ## Errors Failures return the same envelope on every 4xx/5xx, with the matching HTTP status: ```json { "error": { "type": "invalid_request", "code": "invalid_param", "message": "…", "hint": "…", "doc_url": "…" } } ``` `type` is a broad, machine-routable category derived from the status; `code` is the stable machine contract you branch on (never the human `message`). See the `ApiError` schema. ## Idempotency Every `POST` accepts an optional **`Idempotency-Key`** header. Reuse the same key to replay the original result for 24h instead of re-executing — so a retried create can never double-charge or duplicate a record. ## Rate limits & versioning Abuse control is enforced at the edge; responses advertise the policy via the `RateLimit-Policy` header, and a `429` carries `Retry-After`. The API is versioned in the URL path (`/v1`). Breaking changes ship under a new version; a retiring surface is announced with `Deprecation` + `Sunset` response headers at least 90 days ahead.
To set the X-Service-Name http header
Set default HTTP headers in integration tests
Parse and build Accept, Accept-Language, Accept-Encoding, Authorization, Cache-Control, Content-Type, Cookie, Link, CORS, Forwarded, and Via HTTP headers. Includes content negotiation and security header generation.
Extensions for Ruby HTTP stacks to send custom headers on HTTPS CONNECT to a proxy and read headers from the proxy CONNECT response (e.g. X-ProxyMesh-IP).
Stub HTTP requests in tests with a fluent API for matching methods, URLs, headers, and bodies. Includes request recording and scoped isolation.
WinterTc provides a Ruby HTTP client whose interface mirrors the JavaScript Fetch API as closely as possible. It exposes WinterTc::Request, WinterTc::Response, WinterTc::Headers, and WinterTc.fetch — all with the same semantics as their browser counterparts. No runtime gem dependencies: only Ruby's built-in net/http, uri, and json are used.
Instruments outgoing HTTP requests, exports spans to PingOps backend via OTLP, and supports manual tracing with custom attributes, domain filtering, and header redaction.
+Yobi+ is a terminal tool to make +HTTP+ requests and display responses in a friendly way inspired by HTTPie. It allows you to easily send HTTP requests and view the responses in a human-readable format, making it easier to debug and test APIs from the command line. === The main features of Yobi include: * Support for various HTTP methods <i>(GET, POST, PUT, DELETE, etc.)</i> * Customizable request +headers+ and +body+ * Pretty-printed responses with <i>syntax highlighting</i> * <i>Download mode</i> saves response content to a file * <i>Low dependency</i> and <i>easy installation</i> via RubyGems
Simple HTTP proxy which adds authentication headers from Conjur"
HTTP::RetryAfter is a Ruby gem that provides functionality to parse and handle HTTP Retry-After headers, which indicate how long a client should wait before making a follow-up request.
A generic Fluentd output plugin to send logs to an HTTP endpoint with SSL and Header option, extended from kawasakitoshiya@gmail.com's similarily named gem'
Parses Range HTTP headers for specific fetches
# Quick Start The Owner API uses the JSON format, and must be accessed over a [secure connection](https://en.wikipedia.org/wiki/HTTPS). Let’s assume that the access token provided by your account manager is “TOKEN”. Here’s how to get the list of ids of all your invoices from the first week of August with a shell script: ```bash query="end_date=2018-08-08T00%3A00%3A00%2B00%3A00&start_date=2018-08-01T00%3A00%3A00%2B00%3A00" curl -i "https://api-eu.getaround.com/owner/v1/invoices?${query}" \ -H "Authorization: Bearer TOKEN" \ -H "Accept:application/json" \ -H "Content-Type:application/json" ``` And here’s how to get the invoice with the id 12345: ```bash curl -i "https://api-eu.getaround.com/owner/v1/invoices/12345" \ -H "Authorization: Bearer TOKEN" \ -H "Accept: application/json" \ -H "Content-Type: application/json"" ``` See the [endpoints section](#tag/Invoices) of this guide for details about the response format. Dates in request params should follow the ISO 8601 standard. # Authentication All requests must be authenticated with a [bearer token header](https://tools.ietf.org/html/rfc6750#section-2.1). You token will be sent to you by your account manager. Unauthenticated requests will return a 401 status. # Pagination The page number and the number of items per page can be set with the “page” and “per_page” params. For example, this request will return the second page of invoices, and 50 invoices per page: `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` Both of these params are optional. The default page size is 30 items. The Getaround Owner API follows the [RFC 8288 convention](https://datatracker.ietf.org/doc/html/rfc8288) of using the `Link` header to provide the `next` page URL. Please don't build the pagination URLs yourself. The `next` page will be missing when you are requesting the last available page. Here's an example response header from requesting the second page of invoices `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` ``` Link: <https://api-eu.getaround.com/owner/v1/invoices?page=3&per_page=50>; rel="next" ``` # Throttling policy and Date range limitation We have throttling policy that prevents you to perform more than 100 requests per min from the same IP. Also, there is a limitation on the size of the range of dates given in params in some requests. All requests that need start_date and end_date, do not accept a range bigger than 30 days. # Webhooks Getaround can send webhook events that notify your application when certain events happen on your account. This is especially useful to follow the lifecycle of rentals, tracking for example bookings or cancellations. ### Setup To set up an endpoint, you need to define a route on your server for receiving events, and then <a href="mailto:owner-api@getaround.com">ask Getaround</a> to add this URL to your account. To acknowledge receipt of a event, your endpoint must: - Return a `2xx` HTTP status code. - Be a secure `https` endpoint with a valid SSL certificate. ### Testing Once Getaround has set up the endpoint, and it is properly configured as described above, a test `ping` event can be sent by clicking the button below: <form action="/docs/api/owner/fire_ping_webhook" method="post"><input type="submit" value="Send Ping Event"></form> You should receive the following JSON payload: ```json { "data": { "ping": "pong" }, "type": "ping", "occurred_at": "2019-04-18T08:30:05Z" } ``` ### Retries Webhook deliveries will be attempted for up to three days with an exponential back off. After that point the delivery will be abandoned. ### Verifying Signatures Getaround will also provide you with a secret token, which is used to create a hash signature with each payload. This hash signature is passed along with each request in the headers as `X-Drivy-Signature`. Suppose you have a basic server listening to webhooks that looks like this: ```ruby require 'sinatra' require 'json' post '/payload' do push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end ``` The goal is to compute a hash using your secret token, and ensure that the hash from Getaround matches. Getaround uses an HMAC hexdigest to compute the hash, so you could change your server to look a little like this: ```ruby post '/payload' do request.body.rewind payload_body = request.body.read verify_signature(payload_body) push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end def verify_signature(payload_body) signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['SECRET_TOKEN'], payload_body) return halt 500, "Signatures didn't match!" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_DRIVY_SIGNATURE']) end ``` Obviously, your language and server implementations may differ from this code. There are a couple of important things to point out, however: No matter which implementation you use, the hash signature starts with `sha1=`, using the key of your secret token and your payload body. Using a plain `==` operator is not advised. A method like secure_compare performs a "constant time" string comparison, which renders it safe from certain timing attacks against regular equality operators. ### Best Practices - **Acknowledge events immediately**. If your webhook script performs complex logic, or makes network calls, it’s possible that the script would time out before Getaround sees its complete execution. Ideally, your webhook handler code (acknowledging receipt of an event by returning a `2xx` status code) is separate of any other logic you do for that event. - **Handle duplicate events**. Webhook endpoints might occasionally receive the same event more than once. We advise you to guard against duplicated event receipts by making your event processing idempotent. One way of doing this is logging the events you’ve processed, and then not processing already-logged events. - **Do not expect events in order**. Getaround does not guarantee delivery of events in the order in which they are generated. Your endpoint should therefore handle this accordingly. We do provide an `occurred_at` timestamp for each event, though, to help reconcile ordering.
Transport collected data through HTTP header from microservices requests.
Automatically add a `link` header directing clients to `preconnect` to your `asset_host` to HTML document responses in Rails.
Idempotency-Key header support for Grape REST APIs, based on the IETF Idempotency-Key HTTP header draft. Wrap a POST or PATCH endpoint in an idempotent block and clients can safely retry requests after timeouts or network errors without creating duplicate payments, orders or records. The first response (status, headers and body) is stored in Redis and replayed for retries with the same key. Concurrent duplicate requests get a 409 Conflict, and reusing a key with a different payload gets a 422 Unprocessable Entity. Works with Grape 1.x to 4.x and Ruby 2.6+.
The Postman API enables you to programmatically access data stored in your Postman account. For a comprehensive set of examples of requests and responses, see the [**Postman API** collection](https://www.postman.com/postman/workspace/postman-public-workspace/documentation/12959542-c8142d51-e97c-46b6-bd77-52bb66712c9a). ## Important - You must pass an `Accept` header with the `application/vnd.api.v10+json` value to use v10 and higher endpoints. While some of these endpoints may appear the same as the deprecated Postman v9 endpoints, they will use the v10 behavior when you send this `Accept` header. For more information, see [About v9 and v10 APIs](https://learning.postman.com/docs/developer/postman-api/intro-api/#about-v9-and-v10-apis). - To use the **API** endpoints, you must first [update your APIs to the v10 format](https://learning.postman.com/docs/designing-and-developing-your-api/creating-an-api/#upgrading-an-api). ## Getting started You can get started with the Postman API by [forking the Postman API collection](https://learning.postman.com/docs/collaborating-in-postman/version-control/#creating-a-fork) to your workspace. You can then use Postman to send requests. ## About the Postman API - You must use a valid API Key to send requests to the API endpoints. - The API has [rate and usage limits](https://learning.postman.com/docs/developer/postman-api/postman-api-rate-limits/). - The API only responds to HTTPS-secured communications. Any requests sent via HTTP return an HTTP `301` redirect to the corresponding HTTPS resources. - The API returns requests responses in [JSON format](https://en.wikipedia.org/wiki/JSON). When an API request returns an error, it is sent in the JSON response as an error key. - The request method (verb) determines the nature of action you intend to perform. A request made using the `GET` method implies that you want to fetch something from Postman. The `POST` method implies you want to save something new to Postman. - For all requests, API calls respond with their corresponding [HTTP status codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes). In the Postman client, the status code also provides help text that details the possible meaning of the response code. ### IDs and UIDs All items in Postman, such as collections, workspaces, and APIs, have IDs and UIDs: - An ID is the unique ID assigned to a Postman item. For example, `ec29121c-5203-409f-9e84-e83ffc10f226`. - The UID is the **full** ID of a Postman item. This value is the item's unique ID concatenated with the user ID. For example, in the `12345678-ec29121c-5203-409f-9e84-e83ffc10f226` UID: - `12345678` is the user's ID. - `ec29121c-5203-409f-9e84-e83ffc10f226` is the item's ID. ### 503 response An HTTP `503 Service Unavailable` response from our servers indicates there is an unexpected spike in API access traffic. The server is usually operational within the next five minutes. If the outage persists or you receive any other form of an HTTP `5XX` error, [contact support](https://support.postman.com/hc/en-us/requests/new/). ## Authentication Postman uses API keys for authentication. The API key tells the API server that the request came from you. Everything that you have access to in Postman is accessible with your API key. You can [generate](https://learning.postman.com/docs/developer/postman-api/authentication/#generate-a-postman-api-key) a Postman API key in the [**API keys**](https://postman.postman.co/settings/me/api-keys) section of your Postman account settings. You must include an API key in each request to the Postman API with the `X-Api-Key` request header. In Postman, you can store your API key as an [environment variable](https://www.getpostman.com/docs/environments). The Postman API [collection](https://www.getpostman.com/docs/collections) will use it to make API calls. ### Authentication error response If an API key is missing, malformed, or invalid, you will receive an HTTP `401 Unauthorized` response code. ### Using the API key as a query parameter Requests that accept the `X-Api-Key` request header also accept the API key when you send it as the `apikey` query parameter. An API key sent as part of the header has a higher priority when you send the key as both a request header and a query parameter. ## Rate and usage limits API access [rate limits](https://learning.postman.com/docs/developer/postman-api/postman-api-rate-limits/) apply at a per-API key basis in unit time. The limit is **300 requests per minute**. Also, depending on your [plan](https://www.postman.com/pricing/), you may have usage limits. If you exceed either limit, your request will return an HTTP `429 Too Many Requests` status code. Each API response returns the following set of headers to help you identify your use status: | Header | Description | | ------ | ----------- | | `X-RateLimit-Limit` | The maximum number of requests that the consumer is permitted to make per minute. | | `X-RateLimit-Remaining` | The number of requests remaining in the current rate limit window. | | `X-RateLimit-Reset` | The time at which the current rate limit window resets in UTC epoch seconds. | ## Support For help regarding accessing the Postman API, you can: - Visit [Postman Support](https://support.postman.com/hc/en-us) or our [Community and Support](https://www.postman.com/community/) sites. - Reach out to the [Postman community](https://community.postman.com/). - Submit a help request to [Postman support](https://support.postman.com/hc/en-us/requests/new/). ## Policies - [Postman Terms of Service](http://www.postman.com/legal/terms/) - [Postman Privacy Policy](https://www.postman.com/legal/privacy-policy/)