Connect to any inbox or calendar in the world.

import Nylas from 'nylas';

const nylas = new Nylas({ apiKey: '<NYLAS_API_KEY>' });
const sentMessage = await nylas.messages.send({
 identifier: <USER_GRANT_ID>
  requestBody: {
    to: [{ name: '<RECIPIENT_NAME>', email: '<RECIPIENT_EMAIL>' }],
    subject: '<EMAIL_SUBJECT>',
    body: '<EMAIL_BODY>'
  }
});

require 'nylas'

nylas = Nylas::Client.new(api_key: "<NYLAS_API_KEY>")

request_body = {
  subject: '<EMAIL_SUBJECT>',
  body: '<EMAIL_BODY>',
  to: [{ name: '<RECIPIENT_NAME>', email: '<RECIPIENT_EMAIL>' }]
}

email, response = nylas.messages.send('<USER_GRANT_ID>', request_body)

from nylas import Client
nylas = Client(api_key='<NYLAS_API_KEY>')
message = nylas.messages.send(
    '<USER_GRANT_ID>',
    request_body={
        "to": [{ "name": '<RECIPIENT_NAME>', 
        "email": '<RECIPIENT_EMAIL>' }],
        "subject": '<EMAIL_SUBJECT>',
        "body": '<EMAIL_BODY>'
    }
)

import com.nylas.NylasClient
val nylas = NylasClient(apiKey = '<NYLAS_API_KEY>')

val recipients = listOf(EmailName('<RECIPIENT_EMAIL>', '<RECIPIENT_NAME>'))

val requestBody = SendMessageRequest.Builder(recipients)
    .subject('<EMAIL_SUBJECT>')
    .body('<EMAIL_BODY>')
    .build()

val emailResponse = nylas.messages().send('<USER_GRANT_ID>', requestBody)

curl --request POST \
  --url "api.nylas.com/${<USER_GRANT_ID>}/messages/send" \
  --header "Authorization: Bearer ${NYLAS_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{
    "subject": "<EMAIL_SUBJECT>",
    "body": "<EMAIL_BODY>",
    "to": [{"name": "<RECIPIENT_NAME>",
    "email": "<RECIPIENT_EMAIL>"}]
  }'

import Nylas from 'nylas';
const nylas = new Nylas({ apiKey: '<NYLAS_API_KEY>' });
const event = await nylas.events.create({
  identifier: <USER_GRANT_ID>
  requestBody: {
    title: '<EVENT_TITLE>',
    when: { startTime: '<START_TIME>', endTime: '<END_TIME>' },
    location: '<EVENT_LOCATION>'
  },
  queryParams: { calendarId: '<USER_CALENDAR_ID>' }
});

require 'nylas'
nylas = Nylas::Client.new(api_key: '<NYLAS_API_KEY>')
event, _ = nylas.events.create(
  identifier: '<USER_GRANT_ID>',
  query_params: { calendar_id: '<USER_CALENDAR_ID>' },
  request_body: {
    title: '<EVENT_TITLE>',
    when: { start_time: '<START_TIME>', end_time: '<END_TIME>' },
    participants: [{ name: '<RECIPIENT_NAME>', email: '<RECIPIENT_EMAIL>', status: '<REPLY_STATUS>' }]
  }
)

from nylas import Client
nylas = Client(api_key='<NYLAS_API_KEY>')
event = nylas.events.create(
    '<USER_GRANT_ID>',
    request_body={
        "title": '<EVENT_TITLE>',
        "when": {"start_time": '<START_TIME>', "end_time": '<END_TIME>'},
        "participants": [{"email": '<RECIPIENT_EMAIL>', "name": '<RECIPIENT_NAME>'}],
    },
    query_params={"calendar_id": '<USER_CALENDAR_ID>'}
)

val nylas = NylasClient(apiKey = '<NYLAS_API_KEY>')

val participants = listOf(CreateEventRequest.Participant(
    '<RECIPIENT_EMAIL>', ParticipantStatus.NOREPLY, '<RECIPIENT_NAME>'))

val requestBody = CreateEventRequest(
    timespan, '<EVENT_TITLE>', '<EVENT_LOCATION>', 
    "Discuss project timeline and milestones", participants)

val queryParams = CreateEventQueryParams('<USER_CALENDAR_ID>')
val response = nylas.events().create('<USER_GRANT_ID>', requestBody, queryParams)

curl --request POST \
  --url "api.nylas.com/${<USER_GRANT_ID>}/events?calendar_id=${<USER_CALENDAR_ID>}" \
  --header "Authorization: Bearer ${<NYLAS_API_KEY>}" \
  --header "Content-Type: application/json" \
  --data '{
    "title": "<EVENT_TITLE>",
    "when": {"start_time": "<START_TIME>", "end_time": "<END_TIME>"},
    "participants": [ {"email": "<RECIPIENT_EMAIL>", "name": "<RECIPIENT_NAME>"}]
  }'

const nylas = new Nylas({ apiKey: process.env.<NYLAS_API_KEY> });
const contact = await nylas.contacts.create({
 identifier: <USER_GRANT_ID>
  requestBody: {
    givenName: '<CONTACT_GIVEN_NAME>',
    surname: '<CONTACT_SURNAME>',
    emails: [{ email: '<CONTACT_EMAIL>', type: '<EMAIL_TYPE>' }],
    phoneNumbers: [{ number: '<CONTACT_PHONE_NUMBER>', type: '<PHONE_TYPE>' }],
    companyName: '<COMPANY_NAME>'
  }
});

nylas = Nylas::Client.new(api_key: '<NYLAS_API_KEY>')

request_body = {
  given_name: '<CONTACT_GIVEN_NAME>',
  surname: '<CONTACT_SURNAME>',
  emails: [{ email: '<CONTACT_EMAIL>', type: '<EMAIL_TYPE>' }],
  phone_numbers: [{ number: '<CONTACT_PHONE_NUMBER>', type: '<PHONE_TYPE>' }],
}

contact, _ = nylas.contacts.create(identifier: '<USER_GRANT_ID>', request_body: request_body )

nylas = Client(api_key='<NYLAS_API_KEY>')
contact = nylas.contacts.create(
    <USER_GRANT_ID>
    request_body={
        "given_name": '<CONTACT_SURNAME>',
        "surname": '<CONTACT_SURNAME>',
        "emails": [{"email":'<CONTACT_EMAIL>', "type": '<EMAIL_TYPE>'}],
        "phone_numbers": [{"number": '<CONTACT_PHONE_NUMBER>', "type": '<PHONE_TYPE>'}],
        "company_name": '<COMPANY_NAME>'
    }
)

val nylas = NylasClient(apiKey = '<NYLAS_API_KEY>')
val contactRequest = CreateContactRequest.Builder()
    .givenName('<CONTACT_GIVEN_NAME>')
    .surname('<CONTACT_SURNAME>')
    .emails('<CONTACT_EMAIL>')
    .phoneNumbers('<CONTACT_PHONE_NUMBER>')
    .companyName('<COMPANY_NAME>')
    .jobTitle('<JOB_TITLE>')
    .build()

val contact = nylas.contacts().create('<USER_GRANT_ID>', contactRequest)

curl --request POST \
  --url "api.us.nylas.com/${USER_GRANT_ID}/contacts" \
  --data '{
    "given_name": "<CONTACT_GIVEN_NAME>",
    "surname": "<CONTACT_SURNAME>",
    "emails": [{"email": "<CONTACT_EMAIL>", "type": "<EMAIL_TYPE>"}],
    "phone_numbers": [{"number": "<CONTACT_PHONE_NUMBER>", "type": "<PHONE_TYPE>"}],
    "company_name": "<COMPANY_NAME>",
    "job_title": "<JOB_TITLE>"
  }'

import React from 'react';
import { NylasScheduling } from "@nylas/react";

function MeetingBooker() {
  // Displays a Calendar scheduler component that
  // lets users choose from open meeting slots
  return (
    <NylasScheduling configurationId={"<SCHEDULER_CONFIG_ID>"} />
  );
}
export default MeetingBooker;