ReactorSDKADOBE LAUNCH DATA COLLECTION

Quickstart

This guide gets you from zero to a real authenticated ReactorSDK request. The goal is to validate the whole chain: gem install, Adobe credential wiring, client construction, and a successful Launch API call that returns typed Ruby resource objects.

ReactorSDK supports Adobe OAuth server-to-server credentials. Make sure you have an Adobe Developer Console project with the Adobe Launch service enabled before you begin.

Install the gem

Add the gem to your application bundle or install it directly if you are validating the SDK from a shell first.

Ruby
# Add ReactorSDK to your application dependencies.
gem "reactor_sdk"
Read the full installation guide

Create a client

The safest baseline is to inject your Adobe credentials through environment variables and build the client with ENV.fetch so missing configuration fails immediately.

Environment variables

# Adobe Developer Console client ID.
export ADOBE_CLIENT_ID="your-client-id"
# Adobe Developer Console client secret.
export ADOBE_CLIENT_SECRET="your-client-secret"
# IMS organization ID, which normally ends in @AdobeOrg.
export ADOBE_IMS_ORG_ID="your-org-id@AdobeOrg"

Build a client

# Load the gem before you instantiate the client.
require "reactor_sdk"

# Build one reusable client with credentials pulled from the environment.
client = ReactorSDK::Client.new(
  # Client ID from Adobe Developer Console.
  client_id:     ENV.fetch("ADOBE_CLIENT_ID"),
  # Client secret from Adobe Developer Console.
  client_secret: ENV.fetch("ADOBE_CLIENT_SECRET"),
  # IMS organization ID for the Adobe org you want to access.
  org_id:        ENV.fetch("ADOBE_IMS_ORG_ID")
)

Under the hood, the first authenticated request will trigger Adobe IMS token fetch automatically. You do not need to manage bearer tokens manually in application code.

Explore Adobe Launch

Use company and property listing as your first smoke test. It exercises authentication, request signing, automatic pagination, response parsing, and the typed resource layer without forcing you into a more complex write workflow immediately.

First successful requests

# Fetch all companies visible to the current credential set.
companies = client.companies.list
# Pick the first accessible company for this smoke test.
company   = companies.first

# Print the company name and Adobe company ID.
puts "Company: #{company.name} (#{company.id})"

# Load the properties that belong to that company.
properties = client.properties.list_for_company(company.id)

# Print each property ID, display name, and platform.
properties.each do |property|
  puts "#{property.id} - #{property.name} - #{property.platform}"
end

If this works, you already know the SDK can authenticate and talk to Reactor successfully. From there, common next steps include listing rules, enumerating environments and hosts, or loading libraries for a property.

Typical next calls

# Reuse the first property returned by the earlier smoke test.
property = properties.first

# Load rule resources for the property.
rules        = client.rules.list_for_property(property.id)
# Load environment resources for the property.
environments = client.environments.list_for_property(property.id)
# Load host resources for the property.
hosts        = client.hosts.list_for_property(property.id)
# Load library resources for the property.
libraries    = client.libraries.list_for_property(property.id)

If authentication succeeds but companies is empty, the credential set is valid but may not have access to the Launch org or company you expected.

Next steps

Once the quickstart succeeds, move deeper based on what you are trying to automate:

Was this page helpful?