adCenter API Blog for Developers

Microsoft adCenter API Top 10 Viewed Topics for February 2010

2010-03-08T22:44:00Z

Hello,

Here are the most viewed adCenter API topics on MSDN for February 2010.

Microsoft adCenter API
United States
Microsoft adCenter Campaign Management API Reference
Campaign Management Service Operations
California (United States)
Alabama (United States)
Microsoft adCenter Campaign Management API
WSDL Overview
KeywordPerformanceReportColumn Value Set
Microsoft adCenter API Programming Reference

Thank you.

Walter Poupore
Developer Content Manager
Microsoft

CustomerID Now Available in AdCenter Web UI

2010-02-25T17:17:00Z

It is now possible to view your CustomerID in the Microsoft adCenter web user interface. The CustomerID is an identifier that is used in some API calls. To view your CustomerID in the web UI, click on the Accounts & Billing tab after logging in. Then click on the Company Information sub-tab. You will then see a value for the Customer ID value.

Jeff Dillon, API Support

Setting Default Bid Values in adCenter API

2010-02-24T21:20:00Z

We occasionally get questions around the new bid behavior introduced in API Version 6.

Common questions include:

“How do I remove a match type?”

“We updated a keyword bid to zero; we thought we would see a default bid value in the web UI?”

“We never bid for Exact match, so why are we showing .05 cents as the bid in the web UI? An Exact bid doesn’t show up when we retrieve the same keyword bid values via the API.”

So I thought I would take the time to clear things up. Basically, keep in mind the following rules:

Setting a keyword bid amount to “zero” means you do not wish to bid on that match type, hence it is not represented in the UI. So explicitly setting to zero removes a match type.
Passing a “null” value means you DO wish to bid on that match type and the bid amount will be determined by the default ad group bid. The default ad group bid cannot be zero, and its default value is 5 cents. So “null = inherit”.
Passing a non-null, non-zero value for a bid amount will set the bid amount to the value that has been defined.

There is information on MSDN here.

Bid Amounts

When adding a new keyword, you specify to use the default ad group bid by passing null for the bid object. Otherwise, pass the keyword bid amount in the Amount element of the Bid object.

When updating an existing keyword, you specify to use the default ad group bid by passing null for the Amount element of the Bid object. Passing null for the bid object in this case causes the existing bid amount to not be changed. Passing a valid value in the Amount element of the Bid object causes that bid amount to be updated.

You can specify up to two decimal places for the BroadMatchBid, ExactMatchBid, PhraseMatchBid, and ContentMatchBid values.

For more information, see Bid Amounts on MSDN.

I will include an example here. I have set the ad group default bid for Exact to $5. The remaining ad group level bids are left to their default values. At the keyword level, via the API I have set the Broad bid to $2, Phrase bid to zero, and Exact bid to null. As you can see in the web UI screenshot below, the Exact bid is inheriting the ad group value of $5, and shows as non-bolded. The explicitly set $2 Broad bid is showing as bold. The Phrase match type is not displayed in the UI as the keyword value was set to 0, effectively removing this match type.

Jeff Dillon, API Support

How to get the revenue or conversion values using adCenter API?

2010-02-24T17:08:00Z

Customers have asked for new reports that we currently do not provide via the API. These are excellent requests and this is the kind of feedback we welcome via the community and via support. This helps the product team set future direction for feature development.

Currently, using the keyword performance report, you can retrieve the following:

ConversionRate - The conversion rate

Conversions - The number of conversions

CostPerConversion - The cost per conversion.

More report values are described here:

http://msdn.microsoft.com/en-us/library/bb671562.aspx

Customers have expressed interest in reports such as PageviewValue, SignupValue, ConversionVAlue, etc. These values are not currently provided in the adCenter API. New features are added regularly so subscribe to the blog or forums for more information about future additions.

France has 2 Belvezets, so does the adCenter API

2010-02-24T16:55:00Z

A customer recently asked our API support team: “We’ve found two ambiguous targets in the MSDN library http://msdn.microsoft.com/en-us/library/dd797184.aspx:

Belvezet Belvezet, Alès K FR

Belvézet Belvézet, Alès K FR

One with an accent and the other without.

“Are they duplicates?”

Not a technical question, of course, but an opportunity to turn to Bing and see what it tells us. http://www.bing.com/search?q=belvezet&form=QBRE&qs=n&sc=1-6 According to Bing, there are two communes named Belvezet in France.

Belvezet – no accent – is in the Lozère department, traversed by the river Chassezac. Population 81.

Belvézet – with accent – is in the Gard department in southern France. Population 210.

That’s a targeted campaign.

-Chris

Microsoft adCenter API Top 10 Viewed Topics for January 2010

2010-02-23T21:32:00Z

Hello,

Here are the most viewed adCenter API topics on MSDN for January 2010.

Microsoft adCenter API
Microsoft adCenter API Programming Reference
Microsoft adCenter Web Service Addresses
Cashback Rebate Program
Introducing Microsoft adCenter API
WSDL Overview
What’s New in the SDK for the Microsoft adCenter API
Developing with the Microsoft adCenter API
Getting Started with the Microsoft adCenter API
Microsoft adCenter API Overview

Thank you.

Walter Poupore
Developer Content Manager
Microsoft

CustomerID is mandatory for campaign level targeting in adCenter API

2010-02-22T21:29:46Z

Another tip, or FAQ, from our support engineering team:

Since the release of adCenter API v6, we’ve gotten some questions about the use of CustomerID in getting and setting campaign level targeting.

“Why is CustomerID mandatory for this API and not for the others?”

In the version 6 release, targeting was enabled at the campaign-level, and using the object model, the target setting can be refined at the ad group level. Shamit Patel, our program manager for API, explained this well in the blog post on Waterfall Targeting http://community.microsoftadvertising.com/blogs/api/archive/2009/10/13/adcenter-api-campaign-level-targeting-quot-waterfall-targeting-quot.aspx

One of the advantages when coding is that you can create a single target object, save it in your customer library, and use it across all accounts. This is first feature for which we’ve enabled this model. It should be more efficient, however the CustomerID is required for targeting calls.

-Chris

Tip: Spaces around credentials cause adCenter API errors

2010-02-22T21:02:00Z

I’m continuing with our posts on some of the tips shared by our support engineers. These are overlooked steps or easy-to-correct errors that sometimes prompt support questions. As always, if you have followup questions, let us know and I’ll research it with the engineering team and report back.

Be sure to remove the spaces around the credentials in the API calls. Sometimes a space goes unnoticed and this can be a cause for the error: Authentication failed. Either supplied credentials are invalid or the account is inactive.

Sometimes you may see some calls succeed and others fail with the exact same credentials. If you’ve inadvertently left a space around the credentials in one call but not the other, this can be the cause.

For example, check for spaces around the credentials you use in place of the 111...s below:

<?xml version="1.0" encoding="UTF-8"?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Header>
    <ns1:ApplicationToken soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns1="https://adcenter.microsoft.com/v6">
11111111
    </ns1:ApplicationToken>
    <ns2:CustomerAccountId soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns2="https://adcenter.microsoft.com/v6">
111
    </ns2:CustomerAccountId>
    <ns3:CustomerId soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns3="https://adcenter.microsoft.com/v6">

1111
    </ns3:CustomerId>
    <ns4:DeveloperToken soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns4="https://adcenter.microsoft.com/v6">
11111111
    </ns4:DeveloperToken>
    <ns5:Password soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns5="https://adcenter.microsoft.com/v6">
11111111
    </ns5:Password>
    <ns6:UserName soapenv:actor="http://schemas.xmlsoap.org/soap/actor/next" soapenv:mustUnderstand="0" xmlns:ns6="https://adcenter.microsoft.com/v6">
111_11111
    </ns6:UserName>

-Chris

adCenter API users: Microsoft, Yahoo! Search Agreement Cleared

2010-02-17T22:14:00Z

Read the update from Carolyn on the adCenter Blog and read Microsoft VP Darren Huston's Thoughts on the Microsoft and Yahoo! Search Alliance.

Visit the Search Alliance site at www.searchalliance.com for answers to FAQs and additional detail.

Thank you for using the community,

-Chris

Community Program Manager

Use multi-threading to pause more than 100 campaigns

2010-02-17T00:51:00Z

Another tips that comes from our support team:

The current adCenter API includes a limit on the number of campaigns that can be paused or unpaused at any one time. If this limit is exceeded, it will return the error:

1119 The list of campaign Ids exceeds the limit.

If you’re pausing more than 100 campaigns at one time, you will receive an error such as below:

<OperationErrors><OperationError><Code>1119</Code><Details i:nil="true"/>

<ErrorCode>CampaignServiceCampaignIdsArrayExceedsLimit</ErrorCode>

<Message>The list of campaign Ids exceeds the limit.</Message>

</OperationError></OperationErrors>

Some customers have asked for an increase in the limit and this is a pending update.

Meanwhile, the best workaround is to use a multi-threading approach and to pass multiple requests for the pause and resume requirements for your campaigns.

Tips for Using the adCenter API Documentation on MSDN

2010-02-12T20:53:00Z

In 2009, there were well over 200,000 page views in the adCenter API Microsoft Developer Network (MSDN) documentation. We thought you might appreciate a few tips about the adCenter API documentation.

All of the advertising API documentation is located in the MSDN library under Microsoft Advertising Services. Currently, documentation is available for the Atlas APIs as well as the adCenter APIs.
All of the current adCenter API Web service production and sandbox URLs can be found at Microsoft adCenter Web Service Addresses.
Each of the individual adCenter Web services is documented in its own section. In each of these sections, there is a “Release Notes” topic that contains high-level information about the changes to the Web service in the latest release. The What's New in the SDK for the Microsoft adCenter API topic contains the changes to the documentation in the latest release.
In each Web service section, there is a “Developing with” topic that contains detailed information about how to create an application that uses that Web service. This is where you will find code examples for that Web service. For example, the Microsoft adCenter Campaign Management API Examples topic contains code examples for common scenarios using the adCenter campaign management Web service.
Because Web services can be used by any programming language that can support SOAP, there are a vast number of languages in use with the adCenter API. We strive to provide code examples in the most common languages. We have code examples in all of the following languages. In addition to these, we are working on code examples in Ruby. If you know of other languages that we should have code examples in, please let us know by sending email to adCenter SDK Content Feedback.
- C#
- Java
- Perl
- PHP
- Python
- Visual Basic

Troubleshooting adCenter API error: Setting Editorial Status is not allowed.

2010-02-11T16:21:00Z

Developers working with our API sometimes run into errors when executing Update operations in which they try to update an entity's status.

During operations like UpdateCampaigns(), UpdateAdGroups(), UpdateKeywords(), etc, the status of adCenter objects cannot be modified. In addition, editorial status cannot be modified by the user, and is determined and set only by the system.

As a result, a request containing the code below will fail:

<s:Body>

<UpdateKeywordsRequest xmlns="https://adcenter.microsoft.com/v6">

<AdGroupId>******</AdGroupId>

<Keywords xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

<Keyword>

<EditorialStatus>Active</EditorialStatus>

<Id>******</Id>

<Param1>test</Param1>

<Status>Paused</Status>

</Keyword>

</Keywords>

</UpdateKeywordsRequest>

</s:Body>

You can get two possible errors in those cases:

<Message>Status cannot be changed on Update; instead, use Pause or Resume APIs.</Message>

<Message>Setting Editorial Status is not allowed.</Message>

To avoid this error, make sure you set the Status and EditorialStatus of your entities to null when executing Update operations, as in the sample below:

<s:Body>

<UpdateKeywordsRequest xmlns="https://adcenter.microsoft.com/v6">

<AdGroupId>******</AdGroupId>

<Keywords xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

<Keyword>

<EditorialStatus i:nil="true" />

<Id>******</Id>

<Param1>test</Param1>

<Status i:nil="true" />

</Keyword>

</Keywords>

</UpdateKeywordsRequest>

</s:Body>

If you want to update an entity's status, you should use operations like PauseCampaigns(), UpdateCampaigns(), PauseAdGroups(), etc.

Changing the Exception Handling for .NET adCenter API Examples

2010-02-01T20:19:00Z

Just letting you know that we'll be changing the exception handling in our adCenter examples for C# and Visual Basic to reflect the WCF recommended approach for exception handling. Please consider doing the same with your implementations if you are not already doing so.

Currently our examples use try/catch/finally and release the client (call the Close() method) in the finally block. The problem is that Close() can throw exceptions. If Close() throws an exception, you must call the Abort() method to ensure that all resources are released; otherwise, you could be leaking resources on the server. The recommended practice is to call Close() within the try block, and call Abort() from the caught exceptions.

For example,

        static void Main(...)
        {
            try
            {
                service = new CampaignManagementServiceClient("BasicHttpBinding_ICampaignManagementService");
                AddAdGroupsToCampaign(service, ...);
                service.Close();
            }
            catch (CommunicationException e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
            catch (TimeoutException e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
        }

        static void AddAdGroupsToCampaign(service, ...)
        {
            try
            {
                ...

                AddAdGroupsResponse response = service.AddAdGroups(request);
            }
            catch (FaultException<AdApiFaultDetail> fault)
            {
                ...
            }
            catch (FaultException<ApiFaultDetail> fault)
            {
                ...
            }
        }

The following links provide the details from the WCF docs:

Accessing Services Using a WCF Client

Handling Exceptions

Handling exceptions in client applications is straightforward. If a channel is opened, used, and closed inside a try block, then the conversation has succeeded, unless an exception is thrown. Typically, if an exception is thrown the conversation is aborted.

Expected Exceptions

Avoiding Problems with the Using Statement

Thanks and enjoy!

Using the WCFTestClient Tool to Test Service Operations

2010-02-01T18:41:00Z

Hello

In case you didn't know, Visual Studio ships a handy tool called WCFTestClient.exe that you should try. It's a great tool for discovering and testing WSDL operations without writing any code. You can view the request and response messages in a formatted view or in XML. For details, see WCF Test Client (WcfTestClient.exe). There is one catch… it is available only with Visual Studio 2008 SP1.

If you use the default Visual Studio install folder, you can find the tool in the C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\ folder.

After starting the WCF Test Client tool, click File->Add Service, and enter the endpoint address of the service you want to open. For a list of adCenter sandbox addresses, see Microsoft adCenter Web Services Addresses (when you play with this tool, make sure that you use the sandbox addresses and not the production addresses).

The left pane of the WCF Test Client main window lists all the available services, along with their respective endpoints and operations.

When you double-click on an operation in the left pane, the operation is opened in the right pane. The operation's tab shows the request and response properties in either a Formatted or XML view. When you click Formatted, you can enter arbitrary values for the properties to test the service. To send the request to the service, click Invoke.

There is one trick that is not documented or obvious when working with arrays. To specify an array in your request, enter length=n in the Value column, where n is the number of elements that you want in the array. You can then expand the list (click the + sign) to add the values of the array elements.

The following snippets show the progression.

Thanks and enjoy!

Calling adCenter API Operations Asynchronously

2010-02-01T17:51:00Z

Hello

Some of you may be aware of this already but I want to make sure that you know that you can call the CampaignManagement, Administration, and Reporting service operations asynchronously in C# and Visual Basic. For details on calling service operations asynchronously, see the WCF documentation: Synchronous and Asynchronous Operations, How to: Call WCF Service Operations Asynchronously, and Asynchronous Programming Design Patterns.

Asynchronous operations are typically used to perform tasks that might take a long time to complete, such as opening large files, connecting to remote computers, or querying a database. An asynchronous operation executes in a thread separate from the main application thread. When an application calls methods to perform an operation asynchronously, the application can continue executing while the asynchronous method performs its task. Basically, use asynchronous calls when your application can continue doing useful work while the method call runs.

If you use the svcutil.exe utility, include the /async and /tcv:Version35 switches. If you use the Add Service Reference wizard in Visual Studio, click the Advanced… button and check the Generate asynchronous operations checkbox in the Service Reference Settings window (along with the Always generate message contracts checkbox).

You can use event handlers or delegates to receive notification of when the asynchronous call completes. Event handlers are easier to write but delegates offer more flexibility. If you need to pass context information to the callback, you should use delegates. For example, when printing the string that indicates that the group was added, it might be nice to identify the campaign to which the group was added. If you use an event handler, you would need to come up with some external mechanism for keeping track of which campaign goes with which async call result. However, with the delegate model, the context information (in this case, the campaign ID) is passed through to the callback.

I've included examples for both callback models.

The following is a simple example that shows how to call the AddAdGroups operation asynchronously using an event handler.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.ServiceModel;
using AsyncExample.CampaignManagement;

namespace AsyncExample
{
    class Program
    {
        private static Exception asyncException = null;
        private static AutoResetEvent AsyncResultsDone = new AutoResetEvent(false);
        private static CampaignManagementServiceClient service = null;

        static void Main(string[] args)
        {
            if (args.Length != 5)
            {
                Console.WriteLine("usage:\nAsyncExample campaignid username password devtoken accountid");
                return;
            }

            try
            {
                service = new CampaignManagementServiceClient("BasicHttpBinding_ICampaignManagementService");
                AddAdGroupsToCampaign(Convert.ToInt64(args[0]), args[1], args[2], args[3], Convert.ToInt64(args[4]));
                service.Close();
            }
            catch (CommunicationException e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
        }

        static void AddAdGroupsToCampaign(
            long campaignId,
            string username,
            string password,
            string devToken,
            long accountId)
        {
            AddAdGroupsRequest request = new AddAdGroupsRequest();
            request.CustomerAccountId = accountId.ToString();
            request.DeveloperToken = devToken;
            request.UserName = username;
            request.Password = password;

AdGroup[] adGroups = new AdGroup[1];

// Force batch errors by not setting the properties of
// the ad group object.

            adGroups[0] = new AdGroup();
            //adGroups[0].Name = "Skis";
            //adGroups[0].AdDistribution = AdDistribution.Search;
            //adGroups[0].BiddingModel = BiddingModel.Keyword;
            //adGroups[0].PricingModel = PricingModel.Cpc;
            //adGroups[0].LanguageAndRegion = "EnglishUnitedStates";

            //Bid bid = new Bid();
            //bid.Amount = 10.25;
            //adGroups[0].ExactMatchBid = bid;

//adGroups[0].StartDate = null;

            //Date endDate = new Date();
            //endDate.Day = 31;
            //endDate.Month = 3;
            //endDate.Year = 2010;
            //adGroups[0].EndDate = endDate;

request.AdGroups = adGroups;
request.CampaignId = campaignId;

service.AddAdGroupsCompleted += new EventHandler<AddAdGroupsCompletedEventArgs>(AddAdGroupsCallback);
service.AddAdGroupsAsync(request);

// Blocks until the operation completes; released in AddAdGroupsCallback.

AsyncResultsDone.WaitOne();

            if (asyncException != null)
            {
                throw (asyncException);
            }
        }

        static void AddAdGroupsCallback(object sender, AddAdGroupsCompletedEventArgs args)
        {
            // If you need the service object, cast sender to CampaignManagementServiceClient. For example,
            // CampaignManagementServiceClient service = (CampaignManagementServiceClient)sender;

            if (args.Error != null)
            {
                Console.WriteLine("The following error(s) occurred while performing the AddAdGroups operation.\n");

                try
                {
                    throw (args.Error);
                }
                catch (FaultException<ApiFaultDetail> fault)
                {
                    ApiFaultDetail detail = fault.Detail;

// Display the service operation errors.

                    foreach (OperationError error in detail.OperationErrors)
                    {
                        Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.ErrorCode);
                    }

// Display the service operation batch errors.

                    foreach (BatchError error in detail.BatchErrors)
                    {
                        Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.Code);
                    }
                }
                catch (FaultException<AdApiFaultDetail> fault)
                {
                    AdApiFaultDetail detail = fault.Detail;

// Display the generic API errors.

                    foreach (AdApiError error in detail.Errors)
                    {
                        Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.ErrorCode);
                    }
                }
                catch (Exception e)
                {
                    // This will likely be the CommunicationException or TimeoutException
                    // exception. Need to get this exception back to the calling thread to
                    // handle; using the asyncException member for this purpose. The asyncException
                    // member is checked in the calling thread and is thrown if set.

                    asyncException = e;
                }
            }
            else if (args.Cancelled)
            {
                Console.WriteLine("The AddAdGroups operation was canceled.");
            }
            else
            {
                AddAdGroupsResponse response = args.Result;

                foreach (long id in response.AdGroupIds)
                {
                    Console.WriteLine("AdGroup {0} was added", id);
                }
            }

            AsyncResultsDone.Set();
        }
    }
}

The following is a simple example that shows how to call the AddAdGroups operation asynchronously using a delegate.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.ServiceModel;
using AsyncExample.CampaignManagement;

namespace AsyncExample
{
    class Program
    {
        private static AutoResetEvent AsyncResultsDone = new AutoResetEvent(false);
        private static CampaignManagementServiceClient service = null;

                if (service != null)
                {
                    service.Abort();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);

                if (service != null)
                {
                    service.Abort();
                }
            }
        }

// Packages the request object and calls the AddAdGroups operation
// asynchronously.

AdGroup[] adGroups = new AdGroup[1];

// Force batch errors by not setting the properties of
// the ad group object.

            //Bid bid = new Bid();
            //bid.Amount = 10.25;
            //adGroups[0].ExactMatchBid = bid;

//adGroups[0].StartDate = null;

            //Date endDate = new Date();
            //endDate.Day = 31;
            //endDate.Month = 3;
            //endDate.Year = 2010;
            //adGroups[0].EndDate = endDate;

request.AdGroups = adGroups;
request.CampaignId = campaignId;

// Begin the asynchronous call. Use the RequestState object
// to provide context for the call.

RequestState state = new RequestState(service, campaignId);
service.BeginAddAdGroups(request, new AsyncCallback(AddAdGroupsCallback), state);

// Blocks until the operation completes; released in AddAdGroupsCallback.

AsyncResultsDone.WaitOne();

            // If the call failed, throw any exception that the callback did not handle;
            // the callback handles the fault exceptions, so this is likely a communication
            // or timeout exception.

            if (state.UnhandledException != null)
            {
                throw (state.UnhandledException);
            }
        }

// Defines the state object that gives context to the asynchronous call.

        class RequestState
        {
            object context = null;
            Exception unhandledException = null;
            CampaignManagementServiceClient service;

// For this example, the context object is the campaign identifier
// to which the add groups are being added.

            public RequestState(CampaignManagementServiceClient service, object context)
            {
                this.service = service;
                this.context = context;
            }

            public object Context
            {
                get { return context; }
            }

// The exception that the callback did not handle.

            public Exception UnhandledException
            {
                get { return unhandledException; }
                set { this.unhandledException = value; }
            }

// Completes the asynchronous call.

            public AddAdGroupsResponse GetResult(IAsyncResult result)
            {
                return service.EndAddAdGroups(result);
            }
        }

        // Implements the AsyncCallback Delegate. This is called when
        // the operation completes. The delegate processes the response.
        // The delegate handles any fault exceptions but lets the calling
        // thread handle any others.

        static void AddAdGroupsCallback(IAsyncResult result)
        {
            RequestState state = result.AsyncState as RequestState;

            try
            {
                long campaignId = (long)state.Context;
                AddAdGroupsResponse response = state.GetResult(result);

                foreach (long id in response.AdGroupIds)
                {
                    Console.WriteLine("AdGroup {0} was added to campaign {1}", id, campaignId);
                }
            }
            catch (FaultException<AdApiFaultDetail> fault)
            {
                AdApiFaultDetail detail = fault.Detail;

Console.WriteLine("The following error(s) occurred while performing the AddAdGroups operation.\n");

// Display the generic API errors.

                foreach (AdApiError error in detail.Errors)
                {
                    Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.ErrorCode);
                }
            }
            catch (FaultException<ApiFaultDetail> fault)
            {
                ApiFaultDetail detail = fault.Detail;

Console.WriteLine("The following error(s) occurred while performing the AddAdGroups operation.\n");

// Display the service operation errors.

                foreach (OperationError error in detail.OperationErrors)
                {
                    Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.ErrorCode);
                }

// Display the service batch errors.

                foreach (BatchError error in detail.BatchErrors)
                {
                    Console.WriteLine("Message: {0}\nError code: {1}\n", error.Message, error.Code);
                }
            }
            catch (Exception e)
            {
                // Need to get this exception back to the calling thread to handle;
                // using the UnhandledException property of the state object for this
                // purpose. The UnhandledException property is checked in the calling
                // thread and is thrown if set.

                state.UnhandledException = e;
            }
            finally
            {
                // Release the wait in the calling thread.

                AsyncResultsDone.Set();
            }
        }
    }
}

Thanks and enjoy!