- Products
- Solutions Use casesBy industry
- Developers
- Resources Connect
Email API
Calendar API
Scheduler
Contacts API
ExtractAI
Salesforce email integration
Google email & calendar integration
Outlook email & calendar integration
IMAP integration
Calendar management
Embedded contextual email
Scheduling automation
Automated outreach
Intelligent data extraction
Ecommerce
Telehealth
Real estate
Financial technology
Educational technology
Expense management
Customer relationship management
Applicant tracking system
Communications platform
Marketplaces
Document management
Docs
SDKs
Tutorials
API status
Changelog
Support
Blog
Events
Guides
Inspiration gallery
Partners
Build vs. buy
Customer stories
Security & Compliance
Why Nylas
Newsroom
Jump to section
Featured articles
Jump to section
With traditional emailing services, it’s often unknown whether a message will land in the recipient’s inbox, as smart filters can send the message straight into the spam folder. Using the Nylas Connectivity APIs we can ensure that our message will avoid the spam folder with 99.6% probability because the message will be sent from the sender’s individual email account. Additionally, we get the advantage of controlling everything at the API level.
To make things even easier for Ruby developers, we offer the Nylas Ruby SDK. Today we’re going to review how to send emails and attachments with Ruby using the Nylas SDK.
Installing Ruby
Chances are that we already have Ruby installed on our machines. We can check our version by doing the following. (Note that we support Ruby 2.3 and onwards.)
$ ruby -v ruby 2.6.8p205 (2021–07-07 revision 67951) [Universal.arm64-darwin21]
If we don’t happen to have Ruby installed, we can use any of these methods depending on our operating system.
A note about Ruby on Macs
If we’re on Mac, Ruby 2.x will be installed by default, but this version is tied to the operating system and we might get some errors while trying to install gems. We should leave this particular install of Ruby alone.
Instead, we will install rbenv, which is a Ruby Installation Management System. If we don’t have Homebrew already installed, we can just copy and paste this command:
$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Then type these commands on the terminal. The first will install rbenv and the second will simply add to the path:
$ brew install rbenv ruby-build $ export PATH="$HOME/.rbenv/shims:$PATH"
Once we have rbenv installed, we can choose the version of Ruby that we want to install, by typing these commands on the terminal. The first one will initialize rbenv and the second one will show us the available installations:
$ rbenv init $ rbenv install -l
We’re going to choose 3.1.1, so need to type the following commands. The first will install Ruby 3.1.1, the second will define this version as the default, and the last one will give the version currently being used.
$ rbenv install 3.1.1 $ rbenv global 3.1.1 $ ruby -v ruby 3.1.1p18 (2022-02-18 revision 53f5fc4236) [arm64-darwin21]
This will install the latest Ruby version for us.
Installing the Nylas Ruby SDK
We can get the Nylas Ruby SDK package from the gem package manager like this:
$ gem install nylas
Apple stopped bundling OpenSSL with MacOS 10.11. However, one of this gem’s dependencies, EventMachine, requires it. If we’re on El Capitan and above and are unable to install the gem, we can try running the following commands in a terminal:
First, we need to check if we have openssl installed with the following command
$ which openssl /opt/homebrew/bin/openssl
If we don’t have it, we can install it and then instead of manually building the links we can use the second command to have brew make those for us
$ brew install openssl $ brew link openssl --force
Now, we can proceed with installing the Nylas gem
$ gem install nylas
Now, if we’re getting an error about an invalid certificate, we can simply install another useful gem called certified. This gem ensures that we use a certificate and will provide one in case we don’t have one.
$ gem install certified
Storing our Nylas tokens
Let’s go to the Nylas Dashboard (creating a new account if necessary) and get our CLIENT_ID, CLIENT_SECRET, and ACCESS_TOKEN.
If we go to App Settings on the left-side menu, we will find a “Developer Details” section. The CLIENT_ID and CLIENT_SECRET, our Nylas account credentials, are there.
For the connected user account’s ACCESS_TOKEN, we can go to Accounts in the left-side menu, select our account, and then press “Generate New Token”. This will generate a new token for the connected account, allowing us to take actions on the user’s behalf via API.
We now need to store all of our tokens in a safe way in our local project. For that, we’re going to install a package called ruby-dotenv which will help us store environment variables that can be accessed by our code:
$ gem install dotenv
Once installed, and in the root folder where our scripts are going to live, we need to create a file called .env:
$ nano .env
Once the file is created, we need to type the following
export CLIENT_ID = <CLIENT_ID> export CLIENT_SECRET = <CLIENT_SECRET> export ACCESS_TOKEN = <CLIENT_TOKEN>
Then CTRL+O to save and CTRL+X to exit.
Note that you should never commit your `.env` file or tokens to source control like git or services like GitHub.
Sending an Email using Ruby
Now we get to write some code! For my code editor, I’m going to use Geany; however, you can use the IDE of your choice.
I called this file SendEmail.rb:
#!/usr/bin/env ruby
# Import your dependencies
require 'dotenv/load'
require 'nylas'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV['CLIENT_ID'],
app_secret: ENV['CLIENT_SECRET'],
access_token: ENV['ACCESS_TOKEN']
)
# Send your email!
nylas.send!(
to: [{ email: '[email protected]', name: 'Blag' }],
subject: 'With Love, from Nylas',
body: 'This email was sent using the Ruby SDK for the Nylas Email API. Visit https://www.nylas.com for details.'
).to_h
We can run this script from the terminal by using:
$ ruby SendEmail.rb
If everything worked fine, then we can simply open the recipient’s email inbox and read the email we just sent from the Nylas SDK:
Sending an Email with Attachments using Ruby
Just like we can easily send an email, we can add attachments simply as well.
See the new section in the code below under the Create your attachment comment. Note that, in this example, you’ll need an image named “RubyLogo.png” stored in the same folder as your code. (If you want to use the Ruby logo, you can get it here.)
I called this file SendEmailAttachment.py:
#!/usr/bin/env ruby
# Import your dependencies
require 'dotenv/load'
require 'nylas'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV['CLIENT_ID'],
app_secret: ENV['CLIENT_SECRET'],
access_token: ENV['ACCESS_TOKEN']
)
# Open a file and create an attachment
file = nylas.files.create(file: File.open(File.expand_path('RubyLogo.png'), 'r')).to_h
# Send your email with attachments!
nylas.send!(
to: [{ email: '[email protected]', name: 'Blag' }],
subject: 'Ruby with Attachment',
body: 'This email was sent using the Ruby SDK for the Nylas Email API. Visit https://www.nylas.com for details',
file_ids: [file[:id]]
).to_h
We can run this script from the terminal by using:
$ ruby SendEmailAttachment.rb
If everything worked fine, then we can simply open the recipient’s email inbox and read the received email:
And that’s it! As you can see, by using the Nylas Ruby SDK, sending emails becomes an easy task. If you want to learn more, visit our Documentation Page.
Don’t miss the action, watch our LiveStream Coding with Nylas:
