Skip navigation

When it comes to building on the Eloqua platform, one question that comes up quite often is "what is the difference between a Cloud Connector and a Feeder?"

 

The answer to this question is, quite simply, a Program Builder Step.

 

Let me explain...

 

What most people refer to as a Cloud Connector, is an external application configured through the use of a Program Builder Step, that polls Eloqua for Contact records to do "something" with.  These types of applications, through the use of existing contact records, query external systems for data such as webinar/event attendance and social media activity, or perform actions such as sending direct mail and SMS.  Using the Eloqua API, this data is then added to contact records and custom data objects.

 

A Feeder is another type of Cloud Connector.  Feeder applications are developed in the same way as a Cloud Connector "step" application, but they do not poll a Program Builder Step for Contacts.  Feeders are configured externally by Eloqua users, and run on a scheduled, automated basis to "feed" data directly into Eloqua.  These Connectors are used to query external systems for things such as prospects who attended a webinar, viewed an online presentation, or discussed a particular topic on a Social Media website.  The Eloqua API is then used to push this data as leads into an existing contact group in Eloqua.  This contact group can then be used within Eloqua to feed Program Builder programs.

 

Examples of existing Feeders can be found here and here.

 

Hopefully this answers the question above, and brings a little more clarity to the topic.

 

If you are planning on integrating with Eloqua, both types of Cloud Connectors offer many opportunities.

Eloqua’s SOAP API provides some great functionality, including operations for managing Contacts, Emails and Data Transfers. In this post, we’ll introduce the API's Campaign Service, that includes the following operations :

  • Campaign GetCampaign(int id)
  • Campaign[] ListCampaigns()
  • AddAssetToCampaign(CampaignAsset asset, int campaignId)

 

The first two operations involve listing and describing Marketing Campaigns. The last item in the list is AddAssetToCampaign, which allows you to associate assets such as Emails with Marketing Campaigns in your Eloqua install. In this document we'll use a sample written in c# to demonstrate how to associate Eloqua Email's to a Marketing Campaign. We'll also look at how to List and Describe Campaigns using the API.

 

Please note that you will need to add service references to your project for the Email and Campaign Service WSDL documents.

Email Service WSDL : https://secure.eloqua.com/API/1.2/EmailService.svc

Campaign Service WSDL : https://secure.eloqua.com/API/1.2/CampaignService.svc

 

Developers can use these web service to build applications that perform tasks such as displaying, composing and sending emails - as well as associating Emails with Marketing Campaigns.

 

Code Sample c# :

 

try
{
    // Instantiate a new instance of the Email Service with your Credentials
    var emailService = new EmailService.EmailServiceClient();
    emailService.ClientCredentials.UserName.UserName = @"Company\User.Name";
    emailService.ClientCredentials.UserName.Password = "______";

    // Instantiate a new instance of the Campagin Service with your Credentials
    var campaignService = new CampaignService.CampaignServiceClient();
    campaignService.ClientCredentials.UserName.UserName = @"Company\User.Name";
    campaignService.ClientCredentials.UserName.Password = "______";

    // List the campaigns in your Eloqua install
    CampaignService.Campaign[] campaigns = campaignService.ListCampaigns();
    foreach (CampaignService.Campaign campaign in campaigns)
    {
        Console.WriteLine("Id: " + campaign.Id);
        Console.WriteLine("Name: " + campaign.Name);
    }

    // Select a specific Campaign by id
    CampaignService.Campaign c = campaignService.GetCampaign(1);
    Console.WriteLine("Id :" + c.Id);
    Console.WriteLine("Name :" + c.Name);

    Console.WriteLine("Actual cost: " + c.ActualCost);
    Console.WriteLine("BudgetedCost :" + c.BudgetedCost);
    Console.WriteLine("Currency :" + c.Currency);
    Console.WriteLine("Description :" + c.Description);
    Console.WriteLine(" :" + c.EndDate);
    Console.WriteLine(" :" + c.ExternalCampaignID);
    Console.WriteLine(" :" + c.IncludeInROI);
    Console.WriteLine(" :" + c.StartDate);

    EmailService.Email emailDetails = emailService.GetEmailDetails(1);

    CampaignService.CampaignAsset asset = new CampaignAsset();
    asset.Type = CampaignAssetType.Email;
    asset.EntityId = emailDetails.Id;
    asset.Name = emailDetails.Name;

    // Associate the Email with the Campaign
    campaignService.AddAssetToCampaign(asset, c.Id);
} 
catch (Exception ex)
{
    // Display any error messages
    Console.WriteLine(ex.Message);
}

So, now that you have built your Cloud Component Provider, you're ready to give it a test run.

 

Until recently, there was no way to test your Provider, since you cannot self-register your app within the Eloqua application.

 

I am very happy to announce that the Eloqua Cloud Component Test Utility is now available for use!!

 

Simply plug in the URL to your Provider service definition, click Test, and the utility will parse your JSON.

 

The tool will help you determine that all of your Endpoints are working correctly, and will even allow you to Submit your Provider for approval/registration in Eloqua.

 

For detailed instructions on how to use the utility, see Using the Cloud Component Test Utility

In a previous post we discussed how to create and send Emails using Eloqua's SOAP API. You can use the same API to search for and retrieve emails, as well as email content and other properties such as Subject Line and Encoding Type. There are some great use-cases around the use of the API, for example you may wish to create Eloqua Emails using content from your own system and then leverage Eloqua's Email engine to deliver the message.

 

In this post, we'll demonstrate how to search for Emails and retrieve their content using the API. Like all "API How To" guides on this site, we'll assume that you are already familiar with the API Resources on this site - specifically connecting to the Eloqua API.

 

Sample C# code

 

    // Search for Emails with name containing 'Demand'  
    Email[] result = emailClient.SearchEmail("*Demand*");  
    foreach (var email in result)  
    {  
        Console.WriteLine("Id: " + email.Id);  
        Console.WriteLine("Name: " + email.Name);  
    }  

    // List all emails in your system  
    Email[] emails = emailClient.ListEmails();  

    // Iterate over each Email in the list  
    foreach (var email in emails)  
    {  
        // Display the name and subject  
        Console.WriteLine("Email Id: " + email.Id);  
        Console.WriteLine("Email name: " + email.Name);  
        Console.WriteLine("Subject: " + email.Subject);  

        // Retrieve the Email details  
        EmailDetails emailDetails = emailClient.GetEmailDetails(email.Id);  

        // Display some of the details  
        Console.WriteLine("Reply to Name: " + emailDetails.ReplyToName);  
        Console.WriteLine("Reply to Address: " + emailDetails.ReplyToAddress);  
        Console.WriteLine("From Name: " + emailDetails.FromName);  
        Console.WriteLine("From Address: " + emailDetails.FromAddress);  

        Console.WriteLine("HTML Content: " + emailDetails.HtmlContent);  
        Console.WriteLine("Send to Unsubscribes: " + emailDetails.SendToUnsubscribes);  
        Console.WriteLine("Header ID:" + emailDetails.HeaderId); // note : endpoints exist to pull information about the Header  
        Console.WriteLine("Footer ID:" + emailDetails.Footer);        // note : endpoints exist to pull information about the Footer  
    }  

When thinking about building Cloud Components, one thing to consider is the fact that the component does not have to be "visual". 

 

Let me explain...

 

While an embedded YouTube video, or Facebook Like button are obvious choices to add to a landing page, there are also plenty of other possibilities.  You can also do some pretty powerful things with components that are not seen on the rendered page.

 

Since the Cloud Components framework allows you to build out and display an HTML snippet on a page, the possibilities are pretty endless for what you can do.  While this could be an iFrame embed for a YouTube video, it could just as easily be something "non-visual", like some JQuery code that will perform an action on the page.

 

As you are planning and building out your Provider, please keep this in mind.

 

Happy coding!

Have you played with Eloqua’s Email API yet? Eloqua’s SOAP API exposes operations for sending and tracking email messages. It also provides endpoints for creating emails, editing content and configuring details such as the sender and recipient lists. In this post, we’ll demonstrate a very basic use-case that uses this service to create an Email and send it to a list of recipients.


If you're working with Eloqua 10, please see the following post on Sending Emails using the REST API.


Please note that you’ll need to have API access and should be familiar with how to connect with the Eloqua SOAP API. For documentation and additional details please see the Email Service API Overview.

Developers can use this web service to build applications that perform tasks such as displaying, composing and sending emails. As an example, consumers could leverage the API to create their own Eloqua Email Editor.

We’re starting with the basics in this post. The following code sample demonstrates how to create and send an Email via the SOAP API. Please note that you will need to add a service reference to the Email Service WSDL in your application.

Email Service WSDL : https://secure.eloqua.com/API/1.2/EmailService.svc

Sample code c#



    // Instantiate a new instance of the Email client
    EmailServiceClient emailClient = new EmailServiceClient();

    // Set your API user credentials
    emailClient.ClientCredentials.UserName.UserName = @"ClientName\UserName";
    emailClient.ClientCredentials.UserName.Password = "xxxxx";

    // Set the email details
    EmailDetails email = new EmailDetails
                                            {
                                                BouncebackAddress = "admin@eloqua.com",
                                                Name = "Email Service Client - Sample Code",
                                                FromAddress = "",
                                                FromName = "",
                                                ReplyToAddress = "",
                                                ReplyToName = "",
                                                NeverExpires = true,
                                                SendToUnsubscribes = false,
                                                HtmlContent = "<html><body></body></html>",
                                                TextContent = "",
                                                AutoGenerateTextContent = true,
                                                Subject = "Email Service Client - Sample Code",
                                                Tracked = true,
                                                SendHtml = true,
                                                HeaderId = 106, // see endpoints for listing Headers
                                                FooterId = 3, // see endpoints for listing Footers
                                                EncodingId = 1,
                                                GroupId = 1,
                                            };

    try
    {
        // Invoke a service request to create the Email
        email.Id = emailClient.CreateHtmlEmail(email);

        // Update the Email's content
        email.HtmlContent = "<html><body>Updated Content</body></html>";

        // Invoke a service request to update the Email
        emailClient.UpdateHtmlEmail(email);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

    // Configure the Email deployment settings
    DeploymentSettings settings = new DeploymentSettings
                                        {
                                            Name = "Deployment Settings - Sample",
                                            EmailId = email.Id,
                                            AllowResend = false,
                                            DistributionListId = 1,
                                            NotificationEmailAddress = "fred.sakr@eloqua.com",
                                            SignatureRuleId = 3,
                                            SendOnBehalfOfUser = "fred.sakr@eloqua.com",
                                            AllowSendToBouncebacked = false,
                                            AllowSendToUnsubscribed = false,
                                            AllowSendToEmailGroupUnsubscribed = false,
                                            AllowSendToMasterExcludeList = false,
                                        };

    try
    {
        // Deploy the Email
        Deployment deploy = emailClient.Deploy(settings);

        // Retrieve the state
        deploy = emailClient.GetDeployment(deploy.Id);

        // Write your own custom code to poll the API and verify the state of the deployment
        Console.WriteLine(deploy.State);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }