{"id":19123315,"url":"https://github.com/vonage/vonage-ruby-sdk","last_synced_at":"2026-02-03T13:12:33.076Z","repository":{"id":38361293,"uuid":"2263080","full_name":"Vonage/vonage-ruby-sdk","owner":"Vonage","description":"Vonage REST API client for Ruby. API support for SMS, Voice, Text-to-Speech, Numbers, Verify (2FA) and more.","archived":false,"fork":false,"pushed_at":"2024-10-24T09:36:21.000Z","size":1160,"stargazers_count":218,"open_issues_count":3,"forks_count":105,"subscribers_count":28,"default_branch":"main","last_synced_at":"2024-10-25T02:54:39.675Z","etag":null,"topics":["developer-destination","messaging","nexmo","phone","ruby","server-sdk","sms","text-message","text-to-speech","two-factor-authentication","voice","vonage"],"latest_commit_sha":null,"homepage":"https://developer.vonage.com","language":"Ruby","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Vonage.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGES.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.txt","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2011-08-24T17:33:47.000Z","updated_at":"2024-10-24T09:33:22.000Z","dependencies_parsed_at":"2023-02-19T20:15:50.478Z","dependency_job_id":"c040226b-3134-4c75-9835-16b052eea2c3","html_url":"https://github.com/Vonage/vonage-ruby-sdk","commit_stats":{"total_commits":716,"total_committers":25,"mean_commits":28.64,"dds":0.3365921787709497,"last_synced_commit":"13a68104627660916be72006044ed0f0fec8e4d9"},"previous_names":[],"tags_count":88,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Vonage%2Fvonage-ruby-sdk","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Vonage%2Fvonage-ruby-sdk/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Vonage%2Fvonage-ruby-sdk/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Vonage%2Fvonage-ruby-sdk/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Vonage","download_url":"https://codeload.github.com/Vonage/vonage-ruby-sdk/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248708447,"owners_count":21149001,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["developer-destination","messaging","nexmo","phone","ruby","server-sdk","sms","text-message","text-to-speech","two-factor-authentication","voice","vonage"],"created_at":"2024-11-09T05:25:07.245Z","updated_at":"2026-02-03T13:12:33.070Z","avatar_url":"https://github.com/Vonage.png","language":"Ruby","readme":"# Vonage Server SDK for Ruby\n\n[![Gem Version](https://badge.fury.io/rb/vonage.svg)](https://badge.fury.io/rb/vonage) ![Coverage Status](https://github.com/Vonage/vonage-ruby-sdk/workflows/CI/badge.svg) [![codecov](https://codecov.io/gh/Vonage/vonage-ruby-sdk/branch/7.x/graph/badge.svg?token=FKW6KL532P)](https://codecov.io/gh/Vonage/vonage-ruby-sdk)\n\n\n\u003cimg src=\"https://developer.nexmo.com/assets/images/Vonage_Nexmo.svg\" height=\"48px\" alt=\"Nexmo is now known as Vonage\" /\u003e\n\nThis is the Ruby Server SDK for Vonage APIs. To use it you'll\nneed a Vonage account. Sign up [for free at vonage.com][signup].\n\n* [Requirements](#requirements)\n* [Installation](#installation)\n* [Usage](#usage)\n    * [Authentication](#authentication)\n      * [Basic Authentication](#basic-authentication)\n      * [JWT Authentication](#jwt-authentication)\n      * [Signature Authentication](#signature-authentication)\n    * [Logging](#logging)\n    * [Exceptions](#exceptions)\n    * [Overriding the default hosts](#overriding-the-default-hosts)\n    * [HTTP Client Configuration](#http-client-configuration)\n    * [JWT authentication](#jwt-authentication)\n    * [Webhook signatures](#webhook-signatures)\n    * [Pagination](#pagination)\n    * [Messages API](#messages-api)\n    * [Verify API v2](#verify-api-v2)\n    * [Voice API](#voice-api)\n      * [NCCO Builder](#ncco-builder)\n    * [Identity Insights API](#identity-insights-api)\n* [Documentation](#documentation)\n* [Supported APIs](#supported-apis)\n* [Other SDKs and Tools](#other-sdks-and-tools)\n* [License](#license)\n* [Contribute](#contribute)\n\n\n## Requirements\n\nVonage Ruby supports MRI/CRuby (2.5 or newer), JRuby (9.2.x), and Truffleruby.\n\n\n## Installation\n\nTo install the Ruby Server SDK using Rubygems:\n\n    gem install vonage\n\nAlternatively you can clone the repository:\n\n    git clone git@github.com:Vonage/vonage-ruby-sdk.git\n\n\n## Usage\n\nBegin by requiring the Vonage library:\n\n```ruby\nrequire 'vonage'\n```\n\nThen construct a client object with your key and secret:\n\n```ruby\nclient = Vonage::Client.new\n```\n\nYou can now use the client object to call Vonage APIs. For example, to send an SMS:\n\n```ruby\nclient.sms.send(from: 'Ruby', to: '447700900000', text: 'Hello world')\n```\n\nWhen instantiating the `Client` object you can pass in various arguments to configure it such as credentials for [authentication](#authentication), values for [overriding the default hosts](overriding-the-default-hosts), or [configuration options for the HTTP client](#http-client-configuration).\n\n### Authentication\n\nAll requests to the Vonage APIs are authenticated, so the `Client` object will need access to your Vonage credentials. Different Vonage API products support different authenitcations methods, so the credentials required will depend on the authenticaton method used. A few API products also support [multiple authentication methods](#products-with-multiple-authentication-methods).\n\nCurrently, all Vonage API products support one or more of the following authentication methods:\n\n- [Basic Authentication](#basic-authentication)\n- [JWT Authentication](#jwt-authentication)\n- [Signature Authentication](#signature-authentication)\n\nFor a complete list of which products support which authentication methods, please refer to the [Vonage documentation on this topic](https://developer.vonage.com/en/getting-started/concepts/authentication).\n\nProviding the necessary credentials to the client can be done in a number of ways. You can pass the credentials as keyword arguments when calling `Client.new`, for example in order to provide you API Key and API Secret you could use the `api_key` and `api_secret` keyword arguments respectively. You can pass the value for these arguments directly in the method call like so:\n\n```ruby\nclient = Vonage::Client.new(api_key: 'abc123', api_secret: 'abc123456789')\n```\n\nGenerally though, and especially for production code or any code that you plan to push up to source control, you will want to avoid exposing your credentials directly in this way and instead use environment variables to define your credentials.\n\n\u003e [!CAUTION]\n\u003e When setting environment variables locally, if using a file to do this (such as in an `.env` file), you should include the name of that file in a `.gitignore` file if you are intending to push your code up to source control.\n\nYou can choose to define your own custom environment variables and then use Ruby's `ENV` hash to pass them in as the values for your keyword arguments, for example:\n\n```ruby\nclient = Vonage::Client.new(api_key: ENV['MY_API_KEY'], api_secret: ENV['MY_API_SECRET'])\n```\n\nA less verbose approach is to instantiate the client *without* passing in keyword arguments for the authentication credentials. \n\n```ruby\nclient = Vonage::Client.new\n```\n\nIn this case the `Config` object used by the `Client` will search your environment for some pre-defined environment variables and use the values of those variables if defined. The names of these pre-defined environment variables are outlined in the sections below on the specific authentication methods.\n\nNote that some Vonage API products support multiple authentication methods. In these cases the Ruby SDK sets a default authentication method for that product, which can be over-ridden with a configuration setting. You can learn more about this in the section on [Products with Multiple Authentication Methods](#products-with-multiple-authentication-methods).\n\n#### Basic Authentication\n\nFor products that use Basic Authentication, the Ruby SDK sets an `Authorization` header on the HTTP request with a value containing a Base64 encoded version of your API key and secret. You can read more about this authentication method in the [Vonage documentation](https://developer.vonage.com/en/getting-started/concepts/authentication?source=getting-started#basic-authentication).\n\nTo set the header the SDK requires access to your API Key and API Secret. You can either:\n\n1. Pass them in to the `Client` constructor as `api_key` and `api_secret` keyword arguments, either passing in the values directly or as environement variables with custom keys:\n    ```ruby\n    client = Vonage::Client.new(api_key: 'abc123', api_secret: 'abc123456789')\n    ```\n    or\n    ```\n    # .env\n    MY_API_KEY=abc123\n    MY_API_SECRET=abc123456789\n    ```\n    ```ruby\n    client = Vonage::Client.new(api_key: ENV['MY_API_KEY'], api_secret: ENV['MY_API_SECRET'])\n    ```\n\n2. Set them as environment variables with the `VONAGE_API_KEY` and `VONAGE_API_SECRET` keys and then call the constructor without the keyword arguments:\n    ```\n    # .env\n    VONAGE_API_KEY=abc123\n    VONAGE_API_SECRET=abc123456789\n    ```\n    ```ruby\n    client = Vonage::Client.new\n    ```\n\n#### JWT Authentication\n\nFor products that use Bearer (JWT) Authentication, the Ruby SDK sets an `Authorization` header on the HTTP request with a value containing a JSON Web Token (JWT) derived from an Application ID and Private Key. You can read more about this authentication method in the [Vonage documentation](https://developer.vonage.com/en/getting-started/concepts/authentication#json-web-tokens), but in brief you will need to create a Vonage Application (for example via the [Vonage Developer Dashboard](https://dashboard.vonage.com/applications), [Application API](https://developer.vonage.com/en/application/overview), or [Vonage CLI](https://github.com/vonage/vonage-cli)). This Application will be assigned a unique ID upon creation. You can then generate a public and private key pair specific to this Application.\n\nThe Ruby SDK automatically generates the JWT and sets the `Authorization` header for you. To do this it requires access to an Application ID and assocaited Private Key. You can either:\n\n1. Pass them in to the `Client` constructor as `application_id` and `private_key` keyword arguments, either passing in the values directly or as environement variables with custom keys:\n    ```ruby\n    client = Vonage::Client.new(\n      application_id: '78d335fa-323d-0114-9c3d-d6f0d48968cf',\n      private_key: '-----BEGIN PRIVATE KEY----- MIIEvQIBADANBgkqhkiG9w0BAQEFA........'\n    )\n    ```\n    or\n    ```\n    # .env\n    MY_APPLICATION_ID=78d335fa-323d-0114-9c3d-d6f0d48968cf\n    MY_PRIVATE_KEY=-----BEGIN PRIVATE KEY----- MIIEvQIBADANBgkqhkiG9w0BAQEFA........\n    ```\n    ```ruby\n    client = Vonage::Client.new(application_id: ENV['MY_APPLICATION_ID'], private_key: ENV['MY_PRIVATE_KEY'])\n    ```\n  \n2. Set them as environment variables with the `VONAGE_APPLICATION_ID` and `VONAGE_PRIVATE_KEY` keys and then call the constructor without the keyword arguments:\n    ```\n    # .env\n    VONAGE_APPLICATION_ID=78d335fa-323d-0114-9c3d-d6f0d48968cf\n    VONAGE_PRIVATE_KEY=-----BEGIN PRIVATE KEY----- MIIEvQIBADANBgkqhkiG9w0BAQEFA........\n    ```\n    ```ruby\n    client = Vonage::Client.new\n    ```\n\n##### Using a Private Key File\n\nUsing the private key directly, whether to pass it in as a keyword argument or set it as an environment variable, can be a litle bit unweildy. Another option is to store it in a `.key` file and then read the contents of that file in as necessary.\n\n\u003e [!CAUTION]\n\u003e You should include the name of your Private Key file in a `.gitignore` file if you are intending to push your code up to source control.\n\nFor example, if you had your private key stored in a file called `private.key` in the root directory of your Ruby application, you could:\n\n1. Read the contents of the file in using Ruby's `File.read` method when passing the `private_key` keyword argument to the `Client` constructor, either by passing the filepath directly or as an environement variables with a custom key:\n    ```ruby\n    client = Vonage::Client.new(\n      application_id: '78d335fa-323d-0114-9c3d-d6f0d48968cf',\n      private_key: File.read('/private.key)\n    )\n    ```\n    or\n    ```\n    # .env\n    MY_APPLICATION_ID=78d335fa-323d-0114-9c3d-d6f0d48968cf\n    MY_PRIVATE_KEY_PATH=/private.key\n    ```\n    ```ruby\n    client = Vonage::Client.new(application_id: ENV['MY_APPLICATION_ID'], private_key: File.read(ENV['MY_PRIVATE_KEY_PATH']))\n    ```\n\n2. Set the path as an environment variable with the `VONAGE_PRIVATE_KEY_PATH` key (note: this is used in place of the `VONAGE_PRIVATE_KEY` key) and then call the constructor without the keyword arguments:\n    ```\n    # .env\n    VONAGE_APPLICATION_ID=78d335fa-323d-0114-9c3d-d6f0d48968cf\n    VONAGE_PRIVATE_KEY_PATH=/private.key\n    ```\n    ```ruby\n    client = Vonage::Client.new\n    ```\n\n    If `VONAGE_PRIVATE_KEY_PATH` is set, then the Ruby SDK will attempt to read in the contents of the file at the path provided and use those contents as the Private Key.\n\n\u003e [!TIP]\n\u003e You can download your Private Key file when creating or updating a Vonage Application in the [Vonage Developer Dashboard](https://dashboard.vonage.com/applications), or creating a Vonage Application with the [Vonage CLI](https://github.com/vonage/vonage-cli). You can also create your own file using the value of the `keys.private_key` param provided in the HTTP response when creating a Vonage Application using the [Application API](https://developer.vonage.com/en/application/overview).\n\n##### Custom JWTs\n\nBy default the library generates a short lived JWT per request (the default `ttl` is `900` seconds). If you need to generate a long lived JWT for multiple requests or specify JWT claims directly use `Vonage::JWT.generate` to generate a custom JWT and then pass that in to the `Client` constructor using the `token` option. For example:\n\n```ruby\nclaims = {\n  application_id: ENV['VONAGE_APPLICATION_ID'],\n  private_key: File.read(ENV['VONAGE_PRIVATE_KEY_PATH']),\n  nbf: 1483315200,\n  ttl: 3600\n}\n\ntoken = Vonage::JWT.generate(claims)\n\nclient = Vonage::Client.new(token: token)\n```\n\nThe `Client` object will then use the JWT that you passed in for any API requests rather than generating one on-the-fly for each request.\n\n\u003e [!NOTE]  \n\u003e 1. Unlike with the `Client` constructor, you **must** set `application_id` and `private_key` as key-value pairs in the `claims` Hash when generating a custom JWT.\n\u003e 2. You can choose to set *either* `ttl` *or* `exp` in the `claims`:\n\u003e     - If you set *both* `ttl` is ignored and `exp` is used\n\u003e     - If you choose to set `exp` this must be set as the number of seconds since the UNIX epoch (if using `ttl` the generator calculates this for you)\n\nDocumentation for the Vonage Ruby JWT generator gem can be found at: https://www.rubydoc.info/gems/vonage-jwt\n\nThe documentation outlines all the possible parameters you can use to customize and build a token with.\n\n#### Signature Authentication\n\nSignature authentication signs the request using a signature created via a signing algorithm and using your Vonage Signature Secret. You can read more about this authentication method in the [Vonage documentation](https://developer.vonage.com/en/getting-started/concepts/signing-messages).\n\nTo create the signature the SDK requires access to your API Key and Signature Secret. You can either:\n\n1. Pass them in to the `Client` constructor as `api_key` and `signature_secret` keyword arguments, either passing in the values directly or as environement variables with custom keys:\n    ```ruby\n    client = Vonage::Client.new(api_key: 'abc123', signature_secret: 'hdEooIhQYgo5XAcmbfLfpy5ROcEwGbjcwj6EvywwvYNOxKWj71')\n    ```\n    or\n    ```\n    # .env\n    MY_API_KEY=abc123\n    MY_SIGNATURE_SECRET=hdEooIhQYgo5XAcmbfLfpy5ROcEwGbjcwj6EvywwvYNOxKWj71\n    ```\n    ```ruby\n    client = Vonage::Client.new(api_key: ENV['MY_API_KEY'], api_secret: ENV['MY_SIGNATURE_SECRET'])\n    ```\n\n2. Set them as environment variables with the `VONAGE_API_KEY` and `VONAGE_SIGNATURE_SECRET` keys and then call the constructor without the keyword arguments:\n    ```\n    # .env\n    VONAGE_API_KEY=abc123\n    VONAGE_SIGNATURE_SECRET=hdEooIhQYgo5XAcmbfLfpy5ROcEwGbjcwj6EvywwvYNOxKWj71\n    ```\n    ```ruby\n    client = Vonage::Client.new\n    ```\n\nBy default, the Ruby SDK uses the MD5 HASH algorithm to generate the signature. If you've set a different algorithm in your [Vonage API Settings](https://dashboard.vonage.com/settings), you'll need to over-ride the default when instantiating the `Client` object, for example:\n\n```ruby\n  client = Vonage::Client.new(\n    api_key: 'abc123',\n    signature_secret: 'hdEooIhQYgo5XAcmbfLfpy5ROcEwGbjcwj6EvywwvYNOxKWj71',\n    signature_method: 'sha512'\n  )\n```\n\nYou can also set the Signature Method as the `VONAGE_SIGNATURE_METHOD` environment variable, for example:\n\n```\n# .env\nVONAGE_API_KEY=abc123\nVONAGE_SIGNATURE_SECRET=hdEooIhQYgo5XAcmbfLfpy5ROcEwGbjcwj6EvywwvYNOxKWj71\nVONAGE_SIGNATURE_METHOD=sha512\n```\n```ruby\nclient = Vonage::Client.new\n```\n\nSupported algorithms are:\n\n- `md5hash`\n- `md5` (HMAC)\n- `sha1`\n- `sha256`\n- `sha512`\n\n#### Products with Multiple Authentication Methods\n\nSome Vonage API products support more than one authentication method. For these products the Ruby SDK sets a default authentication method, but this default can be over-ridden in the `Client` configuration using the `authentication_preference` setting. For example, the Messages API supports both Basic Authentication and Bearer Token (JWT) Authentication. For its Messages API implementation the Ruby SDK defaults to Bearer Token (JWT) Authentication and so you would normally need to provide a Vonage Application ID and Private Key as credentials in order to authenticate when using the Messages API via the Ruby SDK. However, you can instead provide your Vonage API Key and API Secret and set the `Client` object to use Basic Authentication instead:\n\n```\n# .env\nVONAGE_API_KEY=abc123\nVONAGE_API_SECRET=abc123456789\n```\n\n```ruby\nclient = Vonage::Client.new(authentication_preference: :basic)\n```\n\nBelow is a list of Vonage API products currently implemented in the Ruby SDK that support more than one authentication method.\n\n| Product | Authentication Methods | Default | Over-ride Key |\n|---|---|---|---|\n| Messages API | JWT, Basic | JWT | `:basic` |\n| Verify API v2 | JWT, Basic | JWT | `:basic` |\n| SMS API | Basic, Signature | Basic | `:signature` |\n\n### Logging\n\nUse the logger option to specify a logger. For example:\n\n```ruby\nrequire 'logger'\n\nlogger = Logger.new(STDOUT)\n\nclient = Vonage::Client.new(logger: logger)\n```\n\nBy default the library sets the logger to `Rails.logger` if it is defined.\n\nTo disable logging set the logger to `nil`.\n\n### Exceptions\n\nWhere exceptions result from an error response from the Vonage API (HTTP responses that aren't ion the range `2xx` or `3xx`), the `Net::HTTPResponse` object will be available as a property of the `Exception` object via a `http_response` getter method (where there is no `Net::HTTPResponse` object associated with the exception, the value of `http_response` will be `nil`).\n\nYou can rescue the the exception to access the `http_response`, as well as use other getters provided for specific parts of the response. For example:\n\n```ruby\nbegin\n  verification_request = client.verify2.start_verification(\n    brand: 'Acme',\n    workflow: [{channel: 'sms', to: '44700000000'}]\n  )\nrescue Vonage::APIError =\u003e error\n  if error.http_response\n    error.http_response # =\u003e #\u003cNet::HTTPUnauthorized 401 Unauthorized readbody=true\u003e\n    error.http_response_code # =\u003e \"401\"\n    error.http_response_headers # =\u003e {\"date\"=\u003e[\"Sun, 24 Sep 2023 11:08:47 GMT\"], ...rest of headers}\n    error.http_response_body # =\u003e {\"title\"=\u003e\"Unauthorized\", ...rest of body}\n  end\nend\n```\n\nFor certain legacy API products, such as the [SMS API](https://developer.vonage.com/en/messaging/sms/overview), [Verify v1 API](https://developer.vonage.com/en/verify/verify-v1/overview) and [Number Insight v1 API](https://developer.vonage.com/en/number-insight/overview), a `200` response is received even in situations where there is an API-related error. For exceptions raised in these situation, rather than a `Net::HTTPResponse` object, a `Vonage::Response` object will be made available as a property of the exception via a `response` getter method. The properties on this object will depend on the response data provided by the API endpoint. For example:\n\n```ruby\nbegin\n  sms = client.sms.send(\n    from: 'Vonage',\n    to: '44700000000',\n    text: 'Hello World!'\n  )\nrescue Vonage::Error =\u003e error\n  if error.is_a? Vonage::ServiceError\n    error.response # =\u003e #\u003cVonage::Response:0x0000555b2e49d4f8\u003e\n    error.response.messages.first.status # =\u003e \"4\"\n    error.response.messages.first.error_text # =\u003e \"Bad Credentials\"\n    error.response.http_response # =\u003e #\u003cNet::HTTPOK 200 OK readbody=true\u003e\n  end\nend\n```\n\n### Overriding the default hosts\n\nTo override the default hosts that the SDK uses for HTTP requests, you need to\nspecify the `api_host`, `rest_host` or both in the client configuration. For example:\n\n```ruby\nclient = Vonage::Client.new(\n  api_host: 'api-sg-1.nexmo.com',\n  rest_host: 'rest-sg-1.nexmo.com'\n)\n```\n\nBy default the hosts are set to `api.nexmo.com` and `rest.nexmo.com`, respectively.\n\n### HTTP Client Configuration\n\nIt is possible to set configuration options on the HTTP client. This can be don in a couple of ways.\n\n1. Using an `:http` key during `Vonage::Client` instantiation, for example:\n    ```ruby\n    client = Vonage::Client.new(\n      api_key: 'YOUR-API-KEY',\n      api_secret: 'YOUR-API-SECRET',\n      http: {\n        max_retries: 1\n      }\n    )\n    ```\n\n2. By using the `http=` setter on the `Vonage::Config` object, for example:\n    ```ruby\n    client = Vonage::Client.new(\n      api_key: 'YOUR-API-KEY',\n      api_secret: 'YOUR-API-SECRET'\n    )\n\n    client.config.http = { max_retries: 1 }\n    ```\n\nThe Vonage Ruby SDK uses the [`Net::HTTP::Persistent` library](https://github.com/drbrain/net-http-persistent) as an HTTP client. For available configuration options see [the documentation for that library](https://www.rubydoc.info/gems/net-http-persistent/3.0.0/Net/HTTP/Persistent).\n\n### Webhook signatures\n\nCertain Vonage APIs provide signed [webhooks](https://developer.vonage.com/en/getting-started/concepts/webhooks) as a means of verifying the origin of the webhooks. The exact signing mechanism varies depending on the API.\n\n#### Signature in Request Body\n\nThe [SMS API](https://developer.vonage.com/en/messaging/sms/overview) signs the webhook request using a hash digest. This is assigned to a `sig` parameter in the request body.\n\nYou can verify the webhook request using the `Vonage::SMS#verify_webhook_sig` method. As well as the **request params** from the received webhook, the method also needs access to the signature secret associated with the Vonage account (available from the [Vonage Dashboard](https://dashboard.nexmo.com/settings)), and the signature method used for signing (e.g. `sha512`), again this is based on thes setting in the Dashboard.\n\nThere are a few different ways of providing these values to the method:\n\n1. Pass all values to the method invocation.\n\n```ruby\nclient = Vonage::Client.new\n\nclient.sms.verify_webhook_sig(\n  webhook_params: params,\n  signature_secret: 'secret',\n  signature_method: 'sha512'\n) # =\u003e returns true if the signature is valid, false otherwise\n```\n\n2. Set `signature_secret` and `signature_method` at `Client` instantiation.\n\n```ruby\nclient = Vonage::Client.new(\n  signature_secret: 'secret',\n  signature_method: 'sha512'\n)\n\nclient.sms.verify_webhook_sig(webhook_params: params) # =\u003e returns true if the signature is valid, false otherwise\n```\n\n3. Set `signature_secret` and `signature_method` on the `Config` object.\n\n```ruby\nclient = Vonage::Client.new\nclient.config.signature_secret = 'secret'\nclient.config.signature_method = 'sha512'\n\nclient.sms.verify_webhook_sig(webhook_params: params) # =\u003e returns true if the signature is valid, false otherwise\n```\n\n4. Set `signature_secret` and `signature_method` as environment variables named `VONAGE_SIGNATURE_SECRET` and `VONAGE_SIGNATURE_METHOD`\n\n```ruby\nclient = Vonage::Client.new\n\nclient.sms.verify_webhook_sig(webhook_params: params) # =\u003e returns true if the signature is valid, false otherwise\n```\n\n**Note:** Webhook signing for the SMS API is not switched on by default. You'll need to contact support@vonage.com to enable message signing on your account.\n\n#### Signed JWT in Header\n\nThe [Voice API](https://developer.vonage.com/en/voice/voice-api/overview) and [Messages API](https://developer.vonage.com/en/messages/overview) both include an `Authorization` header in their webhook requests. The value of this header includes a JSON Web Token (JWT) signed using the Signature Secret associated with your Vonage account.\n\nThe `Vonage::Voice` and `Vonage::Messaging` classes both define a `verify_webhook_token` method which can be used to verify the JWT received in the webhook `Authorization` header.\n\nTo verify the JWT, you'll first need to extract it from the `Authorization` header. The header value will look something like the following:\n\n```ruby\n\"Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE1OTUyN\" # remainder of token omitted for brevity\n```\n\nNote: we are only interested in the token itself, which comes *after* the word `Bearer` and the space.\n\nOnce you have extrated the token, you can pass it to the `verify_webhook_token` method in order to verify it.\n\nThe method also needs access to the the method also needs access to the signature secret associated with the Vonage account (available from the [Vonage Dashboard](https://dashboard.nexmo.com/settings)). There are a few different ways of providing this value to the method:\n\n1. Pass all values to the method invocation.\n\n```ruby\nclient = Vonage::Client.new\n\nclient.voice.verify_webhook_token(\n  token: extracted_token,\n  signature_secret: 'secret'\n) # =\u003e returns true if the token is valid, false otherwise\n```\n\n2. Set `signature_secret` at `Client` instantiation.\n\n```ruby\nclient = Vonage::Client.new(\n  signature_secret: 'secret'\n)\n\nclient.voice.verify_webhook_token(token: extracted_token) # =\u003e returns true if the token is valid, false otherwise\n```\n\n3. Set `signature_secret` on the `Config` object.\n\n```ruby\nclient = Vonage::Client.new\nclient.config.signature_secret = 'secret'\nclient.config.signature_method = 'sha512'\n\nclient.voice.verify_webhook_token(token: extracted_token) # =\u003e returns true if the token is valid, false otherwise\n```\n\n4. Set `signature_secret` as an environment variable named `VONAGE_SIGNATURE_SECRET`\n\n```ruby\nclient = Vonage::Client.new\n\nclient.voice.verify_webhook_token(token: extracted_token) # =\u003e returns true if the token is valid, false otherwise\n```\n\n### Pagination\n\nVonage APIs paginate list requests. This means that if a collection is requested that is larger than the API default, the API will return the first page of items in the collection. The Ruby SDK provides an `auto_advance` parameter that will traverse through the pages and return all the results in one response object.\n\nThe `auto_advance` parameter is set to a default of `true` for the following APIs:\n\n* [Account API](https://developer.vonage.com/api/developer/account)\n* [Application API](https://developer.vonage.com/api/application.v2)\n* [Conversation API](https://developer.vonage.com/api/conversation)\n* [Voice API](https://developer.vonage.com/api/voice)\n\nTo modify the `auto_advance` behavior you can specify it in your method:\n\n```ruby\nclient.applications.list(auto_advance: false)\n```\n\n\n## Messages API\n\nThe [Vonage Messages API](https://developer.vonage.com/messages/overview) allows you to send messages over a number of different channels, and various message types within each channel. See the Vonage Developer Documentation for a [complete API reference](https://developer.vonage.com/en/api/messages) listing all the channel and message type combinations.\n\n### Sending a Message\n\nThe Ruby SDK implements a `Messaging` object which can be accessed via a `messaging` method on the `Client` object. The `Messaging` object has a `send` method which lets you send any message type via any channel.\n\n```ruby\nresponse = client.messaging.send(\n  # message data\n)\n```\n\nThere are a number of ways in which you can pass the necessary message data to the method.\n\n**Using Keyword Arguments**\n\nYou can pass the message properties and their values as keyword arguments to the method. For example:\n\n```ruby\nresponse = client.messaging.send(\n  to: '447700900000',\n  from: '447700900001',\n  channel: 'sms',\n  message_type: 'text',\n  text: 'Hello world!'\n)\n```\n\n**Spread a Hash**\n\nFor more complex message structures, you can define the message as a Hash literal and then spread that Hash as keyword arguments by passing it to the `send` method using the double-splat opertator (`**`). For example:\n\n```ruby\nmessage = {\n  to: '447700900000',\n  from: '447700900001',\n  channel: 'mms',\n  message_type: 'image',\n  image: {\n    url: 'https://example.com/image.jpg',\n    caption: 'This is an image'\n  }\n}\n\nresponse = client.messaging.send(**message)\n```\n\n**Using a Combination of Keyword Arguments and Spread**\n\nYou can use a combination of the above two approaches. This might be useful in situations where you want to iteratively send the same message to multiple recipients, for example:\n\n```ruby\nmessage = {\n  from: '447700900000',\n  channel: 'sms',\n  message_type: 'text',\n  text: 'Hello world!'\n}\n\n['447700900001', '447700900002', '447700900003'].each do |to_number|\n  client.messaging.send(to: to_number, **message)\nend\n```\n\n**Using Channel Convenience Methods**\n\nThe Ruby SDK provides convenience methods for each channel which return a Hash object which you can then pass to the `send` method in the same way that you would with a Hash literal. As well as a simpler interface, the convenience methods also provide some basic validation.\n\nOther than SMS (which has only one type -- `text`), these methods require a `:type` argument, which defines the `message_type` of the message within that channel. They also require a `:message` argument, which defvines the message itself; this is a String in the case of `text` messages, and a Hash containing the appopriate properties for other message types (e.g. `image`). You can also optionally pass an `opts` arguments, the value of which should be a Hash which defines any other property that you want to include in the message.\n\n```ruby\n# Using the SMS method like this:\nmessage = client.messaging.sms(to: \"447700900000\", from: \"447700900001\", message: \"Hello world!\")\n\n# is the equivalent of using a Hash literal like this:\nmessage = {\n  channel: \"sms\",\n  to: \"447700900000\",\n  from: \"447700900001\",\n  message_type: \"text\",\n  text: \"Hello world!\"\n}\n```\n\nOnce the message Hash is created, you can then pass it into the `send` method using the double-splat opertator (`**`).\n\n```ruby\nresponse = client.messaging.send(**message)\n```\n\nA few additional examples of using these convenience methods are shown below:\n\n\n```ruby\n# creating an RCS Text message\nmessage = client.messaging.rcs(to: \"447700900000\", from: \"RCS-Agent\", type: 'text', message: 'Hello world!')\n\n# creating a WhatsApp Text message\nmessage = client.messaging.whatsapp(to: \"447700900000\", from: \"447700900001\", type: 'text', message: 'Hello world!')\n\n# creating a WhatsApp Image message\nmessage = client.messaging.whatsapp(to: \"447700900000\", from: \"447700900001\", type: 'image', message: { url: 'https://example.com/image.jpg' })\n\n# creating an MMS audio message with optional properties\nmessage = client.messaging.mms(\n  to: \"447700900000\",\n  from: \"447700900001\",\n  type: 'audio',\n  message: { \n    url: 'https://example.com/audio.mp3'\n  },\n  opts: {\n    client_ref: \"abc123\"\n  }\n)\n```\n\nYou can choose to omit the `to` and/or `from` arguments from the convenience method calls and instead pass them in as keyword arguments during the `send` method invocation.\n\n```ruby\nmessage = client.messaging.sms(from: \"447700900001\", message: \"Hello world!\")\n\n['447700900001', '447700900002', '447700900003'].each do |to_number|\n  client.messaging.send(to: to_number, **message)\nend\n```\n\n### Sending a Message with Failover\n\nThe Messages API lets you define one or more failover messages which will be sent if the initial message is rejected. In the Ruby SDK, this feature is implemented by passing a `failover` keyword argument during the invocation of the `send` method. The value of this argument must be an Array containing one or more Hash objects representing the failover message(s). For example:\n\n```ruby\n# Sending an RCS message with failover to SMS\nrcs_message = messaging.rcs(\n    to: '447900000000',\n    from: 'RCS-Agent',\n    type: 'text',\n    message: 'This is an RCS message. If you see this, RCS is working!'\n  )\n\n  sms_message = messaging.sms(\n    to: '447900000000',\n    from: 'Vonage',\n    message: 'This is a failover SMS message in case RCS fails.'\n  )\n\n  response = messaging.send(**rcs_message, failover: [sms_message])\n```\n\n## Verify API v2\n\nThe [Vonage Verify API v2](https://developer.vonage.com/en/verify/verify-v2/overview) allows you to manage 2FA verification workflows over a number of different channels such as SMS, WhatsApp, WhatsApp Interactive, Voice, Email, and Silent Authentication, either individually or in combination with each other. See the Vonage Developer Documentation for a [complete API reference](https://developer.vonage.com/en/api/verify.v2) listing all the channels, verification options, and callback types.\n\nThe Ruby SDK provides two methods for interacting with the Verify v2 API:\n\n- `Verify2#start_verification`: starts a new verification request. Here you can specify options for the request and the workflow to be used.\n- `Verify2#check_code`: for channels where the end-user is sent a one-time code, this method is used to verify the code against the `request_id` of the verification request created by the `start_verification` method.\n\n### Creating a Verify2 Object\n\n```ruby\nverify = client.verify2\n```\n\n### Making a verification request\n\nFor simple requests, you may prefer to manually set the value for `workflow` (an array of one or more hashes containing the settings for a particular channel) and any optional params.\n\nExample with the required `:brand` and `:workflow` arguments:\n\n```ruby\nverification_request = verify.start_verification(\n  brand: 'Acme',\n  workflow: [{channel: 'sms', to: '447000000000'}]\n)\n```\n\nExample with the required `:brand` and `:workflow` arguments, and an optional `code_length`:\n\n```ruby\nverification_request = verify.start_verification(\n  brand: 'Acme',\n  workflow: [{channel: 'sms', to: '447000000000'}],\n  code_length: 6\n)\n```\n\nFor more complex requests (e.g. with mutliple workflow channels or addtional options), or to take advantage of built-in input validation, you can use the `StartVerificationOptions` object and the `Workflow` and various channel objects or the `WorkflowBuilder`:\n\n#### Create options using StartVerificationOptions object\n\n```ruby\nopts = verify.start_verification_options(\n  locale: 'fr-fr',\n  code_length: 6,\n  client_ref: 'abc-123'\n).to_h\n\nverification_request = verify.start_verification(\n  brand: 'Acme',\n  workflow: [{channel: 'email', to: 'alice.example.com'}],\n  **opts\n)\n```\n\n#### Create workflow using Workflow and Channel objects\n\n```ruby\n# Instantiate a Workflow object\nworkflow = verify.workflow\n\n# Add channels to the workflow\nworkflow \u003c\u003c workflow.sms(to: '447000000000')\nworkflow \u003c\u003c workflow.email(to: 'alice.example.com')\n\n# Channel data is encpsulated in channel objects stored in the Workflow list array\nworkflow.list\n# =\u003e [ #\u003cVonage::Verify2::Channels::SMS:0x0000561474a74778 @channel=\"sms\", @to=\"447000000000\"\u003e,\n  #\u003cVonage::Verify2::Channels::Email:0x0000561474c51a28 @channel=\"email\", @to=\"alice.example.com\"\u003e]\n\n# To use the list as the value for `:workflow` in a `start_verification` request call,\n# the objects must be hashified\nworkflow_list = workflow.hashified_list\n# =\u003e [{:channel=\u003e\"sms\", :to=\u003e\"447000000000\"}, {:channel=\u003e\"email\", :to=\u003e\"alice.example.com\"}]\n\nverification_request = verify.start_verification(brand: 'Acme', workflow: workflow_list)\n```\n\n#### Create a workflow using the WorkflowBuilder\n\n```ruby\nworkflow = verify.workflow_builder.build do |builder|\n  builder.add_voice(to: '447000000001')\n  builder.add_whatsapp(to: '447000000000')\nend\n\nworkflow_list = workflow.hashified_list\n# =\u003e [{:channel=\u003e\"voice\", :to=\u003e\"447000000001\"}, {:channel=\u003e\"whatsapp\", :to=\u003e\"447000000000\"}]\n\nverification_request = verify.start_verification(brand: 'Acme', workflow: workflow_list)\n```\n\n### Cancelling a request\n\nYou can cancel in in-progress verification request\n\n```ruby\n# Get the `request_id` from the Vonage#Response object returned by the `start_verification` method call\nrequest_id = verification_request.request_id\n\nverify.cancel_verification_request(request_id: request_id)\n```\n\n### Checking a code\n\n```ruby\n# Get the `request_id` from the Vonage#Response object returned by the `start_verification` method call\nrequest_id = verification_request.request_id\n\n# Get the one-time code via user input\n# e.g. from params in a route handler or controller action for a form input\ncode = params[:code]\n\nbegin\n  code_check = verify.check_code(request_id: request_id, code: code)\nrescue =\u003e error\n  # an invalid code will raise an exception of type Vonage::ClientError\nend\n\nif code_check.http_response.code == '200'\n  # code is valid\nend\n```\n\n### Working with Verify Custom Templates and Template Fragments\n\nVerify custom templates allow you to customize the message sent to deliver an OTP to your users, rather than using the default Vonage templates. See the [Template Management Guide document](https://developer.vonage.com/en/verify/guides/custom-templates) for more information.\n\n#### Templates\n\n```ruby\n# Get a list of all templates\ntemplate_list = verify.templates.list\n\n# Get details of a specific template\ntemplate = verify.templates.info(template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9')\n\n# Create a new template\nverify.templates.create(name: 'my-template')\n\n# Update an existing template\nverify.templates.update(\n  template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9',\n  name: 'my-updated-template'\n)\n\n# Delete a template\nverify.templates.delete(template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9')\n```\n\n#### Template Fragments\n\n```ruby\n# Get a list of template fragments for a specific template\ntemplate_fragment_list = verify.template_fragments.list(template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9')\n\n# Get details of a specific template fragment\ntemplate_fragment = verify.template_fragments.info(\n  template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9',\n  template_fragment_id: 'c70f446e-997a-4313-a081-60a02a31dc19'\n)\n\n# Create a new template fragement\nverify.template_fragments.create(\n  template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9',\n  channel: 'sms',\n  locale: 'en-gb',\n  text: 'Your code is: ${code}'\n)\n\n# Update an existing template fragment\nverify.template_fragments.update(\n  template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9',\n  template_fragment_id: 'c70f446e-997a-4313-a081-60a02a31dc1',\n  text: 'Your one-time code is: ${code}'\n)\n\n# Delete a template fragment\nverify.template_fragments.delete(\n  template_id: '8f35a1a7-eb2f-4552-8fdf-fffdaee41bc9',\n  template_fragment_id: 'c70f446e-997a-4313-a081-60a02a31dc19'\n)\n```\n\n## Voice API\n\nThe [Vonage Voice API](The [Vonage Verify API v2](https://developer.vonage.com/en/verify/verify-v2/overview) allows you to automate voice interactions by creating calls, streaming audio, playing text to speech, playing DTMF tones, and other actions. See the Vonage Developer Documentation for a [complete API reference](https://developer.vonage.com/en/api/voice) listing all the Voice API capabilities.\n\nThe Ruby SDK provides numerous methods for interacting with the Voice v2 API. Here's an example of using the `create` method to make an outbound text-to-speech call:\n\n```ruby\nresponse = client.voice.create(\n  to: [{\n    type: 'phone',\n    number: '447700900000'\n  }],\n  from: {\n    type: 'phone',\n    number: '447700900001'\n  },\n  answer_url: [\n    'https://raw.githubusercontent.com/nexmo-community/ncco-examples/gh-pages/text-to-speech.json'\n  ]\n)\n```\n\n### NCCO Builder\n\nThe Vonage Voice API accepts instructions via JSON objects called NCCOs. Each NCCO can be made up multiple actions that are executed in the order they are written. The Vonage API Developer Portal contains an [NCCO Reference](https://developer.vonage.com/voice/voice-api/ncco-reference) with instructions and information on all the parameters possible.\n\nThe SDK includes an NCCO builder that you can use to build NCCOs for your Voice API methods.\n\nFor example, to build `talk` and `input` NCCO actions and then combine them into a single NCCO you would do the following:\n\n```ruby\ntalk = Vonage::Voice::Ncco.talk(text: 'Hello World!')\ninput = Vonage::Voice::Ncco.input(type: ['dtmf'], dtmf: { bargeIn: true })\nncco = Vonage::Voice::Ncco.build(talk, input)\n\n# =\u003e [{:action=\u003e\"talk\", :text=\u003e\"Hello World!\"}, {:action=\u003e\"input\", :type=\u003e[\"dtmf\"], :dtmf=\u003e{:bargeIn=\u003etrue}}]\n```\n\nOnce you have the constructed NCCO you can then use it in a Voice API request:\n\n```ruby\nresponse = client.voice.create({\n  to: [{type: 'phone', number: '14843331234'}],\n  from: {type: 'phone', number: '14843335555'},\n  ncco: ncco\n})\n```\n\n## Identity Insights API\n\nThe [Vonage Identity Insights API](https://developer.vonage.com/en/identity-insights/overview) provides real-time access to a broad range of attributes related to the carrier, subscriber, or device associated with a phone number. See the Vonage Developer Documentation for a [complete API reference](https://developer.vonage.com/en/api/identity-insights) listing all available insight types.\n\n\u003e [!NOTE] \n\u003e The Vonage Ruby SDK currently supports the following insight types:\n\u003e   - Format\n\u003e   - Current Carrier\n\u003e   - Original Carrier\n\u003e   - SIM Swap\n\nCalling `identity_insights` on an instance of `Client` returns an `IdentityInsights` object which provides methods for interacting with the Identity Insights API.\n\n```ruby\nclient.identity_insights # =\u003e #\u003cVonage::IdentityInsights\u003e\n```\n\n### Making an Insights Request\n\nYou can make an Identity Insights request by calling the `IdentityInsights#requests` method, for example:\n\n```ruby\nresponse = client.identity_insights.requests(phone_number: '447900000000', insights: { format: {} })\n```\n\n### Using the Insights Builder\n\nThe `IdentityInsights` object implements a `insights_builder` method. This method returns an `InsightsBuilder` object:\n\n```ruby\ninsights_builder = client.identity_insights.insights_builder # =\u003e #\u003cVonage::IdentityInsights::InsightsBuilder @insights={}\u003e\n```\n\nYou can then call various methods on the builder in order to add the insights that you require. Each of these methods returns the calling object, so the method invocations can be chained:\n\n```ruby\ninsights_builder.add_format.add_current_carrier\n# =\u003e #\u003cVonage::IdentityInsights::InsightsBuilder @insights={:format=\u003e{}, :current_carrier=\u003e{}}\u003e\n```\n\nThe builder object can be passed into the `IdentityInsights#requests` method invocation as the value of the `insights` keyword argument:\n\n```ruby\nresponse = client.identity_insights.requests(phone_number: '447900000000', insights: insights_builder)\n```\n\n### Calling the Method with a Block\n\nThe `IdentityInsights#requests` method can also be called with a block. The method yields an `InsightsBuilder` object to the block and expects an `InsightsBuilder` object to be returned by the block.\n\n```ruby\nresponse = client.identity_insights.requests(phone_number: '447900000000', purpose: \"FraudPreventionAndDetection\") do |builder|\n  builder.add_format\n    .add_original_carrier\n    .add_current_carrier\n    .add_sim_swap(period: 2400)\nend\n```\n\n\u003e [!NOTE]\n\u003e When requesting the SIM Swap insight, you should pass the `purpose` keyword argument to the `IdentityInsights#requests` method invocation with a value of `'FraudPreventionAndDetection'`.\n\n## Documentation\n\nVonage Ruby SDK documentation: https://www.rubydoc.info/gems/vonage\n\nVonage Ruby SDK code examples: https://github.com/Vonage/vonage-ruby-code-snippets\n\nVonage APIs API reference: https://developer.vonage.com/api\n\n## Supported APIs\n\nThe following is a list of Vonage APIs for which the Ruby SDK currently provides support:\n\n* [Account API](https://developer.vonage.com/en/account/overview)\n* [Application API](https://developer.vonage.com/en/application/overview)\n* [Conversation API](https://developer.vonage.com/en/conversation/overview)\n* [Identity Insights API](https://developer.vonage.com/en/identity-insights/overview)\n* [Meetings API](https://developer.vonage.com/en/meetings/overview) (deprecated)\n* [Messages API](https://developer.vonage.com/en/messages/overview)\n* [Network Number Verification API](https://developer.vonage.com/en/number-verification/overview) (deprecated)\n* [Network SIM Swap API](https://developer.vonage.com/en/sim-swap/overview) (deprecated)\n* [Number Insight API](https://developer.vonage.com/en/number-insight/overview)\n* [Numbers API](https://developer.vonage.com/en/numbers/overview)\n* [Proactive Connect API](https://developer.vonage.com/en/proactive-connect/overview) *\n* [Redact API](https://developer.vonage.com/en/redact/overview)\n* [SMS API](https://developer.vonage.com/en/messaging/sms/overview)\n* [Subaccounts API](https://developer.vonage.com/en/account/subaccounts/overview)\n* [Verify API](https://developer.vonage.com/en/verify/overview)\n* [Voice API](https://developer.vonage.com/en/verify/overview)\n\n\\* The Proactive Connect API is partially supported in the SDK. Specifically, the Events, Items, and Lists endpoints are supported.\n\n## Other SDKs and Tools\n\nYou can find information about other Vonage SDKs and Tooling on our [Developer Portal](https://developer.vonage.com/en/tools).\n\n\n## License\n\nThis library is released under the [Apache 2.0 License][license]\n\n[signup]: https://dashboard.nexmo.com/sign-up?utm_source=DEV_REL\u0026utm_medium=github\u0026utm_campaign=ruby-client-library\n[license]: LICENSE.txt\n\n## Contribute!\n\n_We :heart: contributions to this library!_\n\nIt is a good idea to [talk to us](https://developer.vonage.com/community/slack)\nfirst if you plan to add any new functionality.\nOtherwise, [bug reports](https://github.com/Vonage/vonage-ruby-sdk/issues),\n[bug fixes](https://github.com/Vonage/vonage-ruby-sdk/pulls) and feedback on the\nlibrary are always appreciated.\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvonage%2Fvonage-ruby-sdk","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvonage%2Fvonage-ruby-sdk","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvonage%2Fvonage-ruby-sdk/lists"}