0
# Conversion Sources Service
1

2
The ConversionSourcesService provides complete management of conversion sources for merchant accounts. It supports both synchronous and asynchronous clients with full CRUD operations, pagination, and comprehensive error handling.
3

4
## Client Initialization
5

6
```python
7
from google.shopping import merchant_conversions_v1
8
from google.oauth2 import service_account
9

10
# Default credentials (ADC)
11
client = merchant_conversions_v1.ConversionSourcesServiceClient()
12

13
# Service account credentials
14
credentials = service_account.Credentials.from_service_account_file("credentials.json")
15
client = merchant_conversions_v1.ConversionSourcesServiceClient(credentials=credentials)
16

17
# Async client
18
async_client = merchant_conversions_v1.ConversionSourcesServiceAsyncClient()
19
```
20

21
## Capabilities
22

23
### Create Conversion Source
24

25
Creates a new conversion source for a merchant account.
26

27
```python { .api }
28
def create_conversion_source(
29
    self,
30
    request: CreateConversionSourceRequest = None,
31
    *,
32
    parent: str = None,
33
    conversion_source: ConversionSource = None,
34
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
35
    timeout: float = None,
36
    metadata: Sequence[Tuple[str, str]] = ()
37
) -> ConversionSource: ...
38

39
# Async version
40
async def create_conversion_source(
41
    self,
42
    request: CreateConversionSourceRequest = None,
43
    *,
44
    parent: str = None,
45
    conversion_source: ConversionSource = None,
46
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
47
    timeout: float = None,
48
    metadata: Sequence[Tuple[str, str]] = ()
49
) -> ConversionSource: ...
50
```
51

52
**Parameters:**
53
- `request`: The request object containing parent and conversion_source
54
- `parent`: Required. The account where the conversion source will be created. Format: `accounts/{account}`
55
- `conversion_source`: Required. The conversion source to create
56
- `retry`: Retry configuration
57
- `timeout`: Request timeout in seconds
58
- `metadata`: Additional metadata for the request
59

60
**Returns:** The created ConversionSource object
61

62
**Usage Example:**
63
```python
64
from google.shopping import merchant_conversions_v1
65

66
client = merchant_conversions_v1.ConversionSourcesServiceClient()
67

68
# Create Google Analytics conversion source
69
ga_link = merchant_conversions_v1.GoogleAnalyticsLink(
70
    property_id=123456789,
71
    attribution_settings=merchant_conversions_v1.AttributionSettings(
72
        attribution_lookback_window_days=30,
73
        attribution_model=merchant_conversions_v1.AttributionSettings.AttributionModel.CROSS_CHANNEL_LAST_CLICK
74
    )
75
)
76

77
conversion_source = merchant_conversions_v1.ConversionSource(
78
    google_analytics_link=ga_link
79
)
80

81
request = merchant_conversions_v1.CreateConversionSourceRequest(
82
    parent="accounts/123456789",
83
    conversion_source=conversion_source
84
)
85

86
response = client.create_conversion_source(request=request)
87
print(f"Created conversion source: {response.name}")
88
```
89

90
### Update Conversion Source
91

92
Updates an existing conversion source.
93

94
```python { .api }
95
def update_conversion_source(
96
    self,
97
    request: UpdateConversionSourceRequest = None,
98
    *,
99
    conversion_source: ConversionSource = None,
100
    update_mask: field_mask_pb2.FieldMask = None,
101
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
102
    timeout: float = None,
103
    metadata: Sequence[Tuple[str, str]] = ()
104
) -> ConversionSource: ...
105

106
# Async version
107
async def update_conversion_source(
108
    self,
109
    request: UpdateConversionSourceRequest = None,
110
    *,
111
    conversion_source: ConversionSource = None,
112
    update_mask: field_mask_pb2.FieldMask = None,
113
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
114
    timeout: float = None,
115
    metadata: Sequence[Tuple[str, str]] = ()
116
) -> ConversionSource: ...
117
```
118

119
**Parameters:**
120
- `request`: The request object containing conversion_source and update_mask
121
- `conversion_source`: Required. The conversion source to update
122
- `update_mask`: Required. List of fields to be updated
123
- `retry`: Retry configuration
124
- `timeout`: Request timeout in seconds
125
- `metadata`: Additional metadata for the request
126

127
**Returns:** The updated ConversionSource object
128

129
### Delete Conversion Source
130

131
Deletes (archives) a conversion source. The source will be archived for 30 days before permanent deletion.
132

133
```python { .api }
134
def delete_conversion_source(
135
    self,
136
    request: DeleteConversionSourceRequest = None,
137
    *,
138
    name: str = None,
139
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
140
    timeout: float = None,
141
    metadata: Sequence[Tuple[str, str]] = ()
142
) -> None: ...
143

144
# Async version
145
async def delete_conversion_source(
146
    self,
147
    request: DeleteConversionSourceRequest = None,
148
    *,
149
    name: str = None,
150
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
151
    timeout: float = None,
152
    metadata: Sequence[Tuple[str, str]] = ()
153
) -> None: ...
154
```
155

156
**Parameters:**
157
- `request`: The request object containing name
158
- `name`: Required. The name of the conversion source to delete. Format: `accounts/{account}/conversionSources/{conversion_source}`
159
- `retry`: Retry configuration
160
- `timeout`: Request timeout in seconds
161
- `metadata`: Additional metadata for the request
162

163
**Returns:** None
164

165
### Undelete Conversion Source
166

167
Restores an archived conversion source within the 30-day recovery window.
168

169
```python { .api }
170
def undelete_conversion_source(
171
    self,
172
    request: UndeleteConversionSourceRequest = None,
173
    *,
174
    name: str = None,
175
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
176
    timeout: float = None,
177
    metadata: Sequence[Tuple[str, str]] = ()
178
) -> ConversionSource: ...
179

180
# Async version
181
async def undelete_conversion_source(
182
    self,
183
    request: UndeleteConversionSourceRequest = None,
184
    *,
185
    name: str = None,
186
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
187
    timeout: float = None,
188
    metadata: Sequence[Tuple[str, str]] = ()
189
) -> ConversionSource: ...
190
```
191

192
**Parameters:**
193
- `request`: The request object containing name
194
- `name`: Required. The name of the conversion source to undelete. Format: `accounts/{account}/conversionSources/{conversion_source}`
195
- `retry`: Retry configuration
196
- `timeout`: Request timeout in seconds
197
- `metadata`: Additional metadata for the request
198

199
**Returns:** The restored ConversionSource object
200

201
### Get Conversion Source
202

203
Retrieves a specific conversion source by its resource name.
204

205
```python { .api }
206
def get_conversion_source(
207
    self,
208
    request: GetConversionSourceRequest = None,
209
    *,
210
    name: str = None,
211
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
212
    timeout: float = None,
213
    metadata: Sequence[Tuple[str, str]] = ()
214
) -> ConversionSource: ...
215

216
# Async version
217
async def get_conversion_source(
218
    self,
219
    request: GetConversionSourceRequest = None,
220
    *,
221
    name: str = None,
222
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
223
    timeout: float = None,
224
    metadata: Sequence[Tuple[str, str]] = ()
225
) -> ConversionSource: ...
226
```
227

228
**Parameters:**
229
- `request`: The request object containing name
230
- `name`: Required. The name of the conversion source to retrieve. Format: `accounts/{account}/conversionSources/{conversion_source}`
231
- `retry`: Retry configuration
232
- `timeout`: Request timeout in seconds
233
- `metadata`: Additional metadata for the request
234

235
**Returns:** The requested ConversionSource object
236

237
### List Conversion Sources
238

239
Lists conversion sources for a merchant account with pagination support.
240

241
```python { .api }
242
def list_conversion_sources(
243
    self,
244
    request: ListConversionSourcesRequest = None,
245
    *,
246
    parent: str = None,
247
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
248
    timeout: float = None,
249
    metadata: Sequence[Tuple[str, str]] = ()
250
) -> pagers.ListConversionSourcesPager: ...
251

252
# Async version
253
async def list_conversion_sources(
254
    self,
255
    request: ListConversionSourcesRequest = None,
256
    *,
257
    parent: str = None,
258
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
259
    timeout: float = None,
260
    metadata: Sequence[Tuple[str, str]] = ()
261
) -> pagers.ListConversionSourcesAsyncPager: ...
262
```
263

264
**Parameters:**
265
- `request`: The request object containing parent, page_size, page_token, and show_deleted
266
- `parent`: Required. The account to list conversion sources for. Format: `accounts/{account}`
267
- `retry`: Retry configuration
268
- `timeout`: Request timeout in seconds
269
- `metadata`: Additional metadata for the request
270

271
**Returns:** A pager object for iterating through the results
272

273
**Usage Example:**
274
```python
275
from google.shopping import merchant_conversions_v1
276

277
client = merchant_conversions_v1.ConversionSourcesServiceClient()
278

279
# List with pagination
280
request = merchant_conversions_v1.ListConversionSourcesRequest(
281
    parent="accounts/123456789",
282
    page_size=10,
283
    show_deleted=False
284
)
285

286
# Iterate through all results (auto-pagination)
287
for conversion_source in client.list_conversion_sources(request=request):
288
    print(f"Name: {conversion_source.name}")
289
    print(f"State: {conversion_source.state}")
290
    if conversion_source.google_analytics_link:
291
        print(f"GA Property ID: {conversion_source.google_analytics_link.property_id}")
292

293
# Manual pagination
294
response = client.list_conversion_sources(request=request)
295
for conversion_source in response.conversion_sources:
296
    print(f"Processing: {conversion_source.name}")
297

298
# Get next page if available
299
if response.next_page_token:
300
    next_request = merchant_conversions_v1.ListConversionSourcesRequest(
301
        parent="accounts/123456789",
302
        page_token=response.next_page_token
303
    )
304
    next_response = client.list_conversion_sources(request=next_request)
305
```
306

307
## Error Handling
308

309
Common exceptions when working with the ConversionSourcesService:
310

311
```python
312
from google.api_core import exceptions
313
from google.shopping import merchant_conversions_v1
314

315
client = merchant_conversions_v1.ConversionSourcesServiceClient()
316

317
try:
318
    request = merchant_conversions_v1.GetConversionSourceRequest(
319
        name="accounts/123/conversionSources/invalid"
320
    )
321
    response = client.get_conversion_source(request=request)
322
except exceptions.NotFound as e:
323
    print(f"Conversion source not found: {e}")
324
except exceptions.PermissionDenied as e:
325
    print(f"Access denied: {e}")
326
except exceptions.InvalidArgument as e:
327
    print(f"Invalid request: {e}")
328
except exceptions.ResourceExhausted as e:
329
    print(f"Quota exceeded: {e}")
330
except exceptions.GoogleAPICallError as e:
331
    print(f"API call failed: {e}")
332
```
333

334
## Context Manager Usage
335

336
```python
337
from google.shopping import merchant_conversions_v1
338

339
# Automatic resource cleanup
340
with merchant_conversions_v1.ConversionSourcesServiceClient() as client:
341
    request = merchant_conversions_v1.ListConversionSourcesRequest(
342
        parent="accounts/123456789"
343
    )
344
    response = client.list_conversion_sources(request=request)
345
    for source in response.conversion_sources:
346
        print(f"Processing: {source.name}")
347
```