---
title: Create MFA Push Credential (FCM_HTTP_V1)
description: This sample uses the POST {{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials operation to create the push credentials for an Android native application that uses Google Play Services.
component: pingone-api
page_id: pingone-api:platform:applications/application-mfa-push-credentials/create-mfa-push-credential-fcm
canonical_url: https://developer.pingidentity.com/pingone-api/platform/applications/application-mfa-push-credentials/create-mfa-push-credential-fcm.html
section_ids:
  prerequisites: Prerequisites
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Create MFA Push Credential (FCM\_HTTP\_V1)

##

```none
POST {{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials
```

This sample uses the `POST {{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials` operation to create the push credentials for an Android native application that uses Google Play Services.

The request URL identifies the environment ID and application ID. The request body includeds the `type` and `googleServiceAccountCredentials` parameters.

Since `googleServiceAccountCredentials` represents credentials, this field is not returned in the response (or in a GET request).

### Prerequisites

* Create an application to get an `appID`. Refer to [Application Operations](../applications-1.html).

> **Collapse: Request Model**
>
> Refer to the [MFA push credentials data model](../application-mfa-push-credentials.html#mfa-push-credentials-data-model) for complete descriptions.
>
> | Property                        | Type   | Required? |
> | ------------------------------- | ------ | --------- |
> | type                            | String | Required  |
> | googleServiceAccountCredentials | String | Required  |

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff '{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer {{accessToken}}");
var body = @"{" + "\n" +
@"    ""type"": ""FCM_HTTP_V1""," + "\n" +
@"    ""googleServiceAccountCredentials"": ""{{googleCredentialsJsonContent}}""" + "\n" +
@"}";
request.AddStringBody(body, DataFormat.Json);
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
```

```golang
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io"
)

func main() {

  url := "{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials"
  method := "POST"

  payload := strings.NewReader(`{
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Authorization", "Bearer {{accessToken}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

```http
POST /v1/environments/{{envID}}/applications/{{appID}}/pushCredentials HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n    \"type\": \"FCM_HTTP_V1\",\n    \"googleServiceAccountCredentials\": \"{{googleCredentialsJsonContent}}\"\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials")
  .method("POST", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer {{accessToken}}")
  .build();
Response response = client.newCall(request).execute();
```

```javascript
var settings = {
  "url": "{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
```

```javascript
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "type": "FCM_HTTP_V1",
    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

```python
import requests
import json

url = "{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials"

payload = json.dumps({
  "type": "FCM_HTTP_V1",
  "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {{accessToken}}'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
```

```php
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
  'follow_redirects' => TRUE
));
$request->setHeader(array(
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {{accessToken}}'
));
$request->setBody('{\n    "type": "FCM_HTTP_V1",\n    "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"\n}');
try {
  $response = $request->send();
  if ($response->getStatus() == 200) {
    echo $response->getBody();
  }
  else {
    echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
    $response->getReasonPhrase();
  }
}
catch(HTTP_Request2_Exception $e) {
  echo 'Error: ' . $e->getMessage();
}
```

```ruby
require "uri"
require "json"
require "net/http"

url = URI("{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer {{accessToken}}"
request.body = JSON.dump({
  "type": "FCM_HTTP_V1",
  "googleServiceAccountCredentials": "{{googleCredentialsJsonContent}}"
})

response = http.request(request)
puts response.read_body
```

```swift
let parameters = "{\n    \"type\": \"FCM_HTTP_V1\",\n    \"googleServiceAccountCredentials\": \"{{googleCredentialsJsonContent}}\"\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/v1/environments/{{envID}}/applications/{{appID}}/pushCredentials")!,timeoutInterval: Double.infinity)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("Bearer {{accessToken}}", forHTTPHeaderField: "Authorization")

request.httpMethod = "POST"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
}

task.resume()
```

### Example Response

201 Created

```json
{
    "_links": {
        "self": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/applications/8370dc35-a30d-45b6-9ff5-58aa943fca7d/pushCredentials/31665f1a-a3bc-460e-86c7-1d15b8305a1c"
        },
        "environment": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        },
        "application": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/applications/8370dc35-a30d-45b6-9ff5-58aa943fca7d"
        }
    },
    "id": "31665f1a-a3bc-460e-86c7-1d15b8305a1c",
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "application": {
        "id": "8370dc35-a30d-45b6-9ff5-58aa943fca7d"
    },
    "createdAt": "2023-05-24T12:47:44.448Z",
    "updatedAt": "2023-05-24T12:47:44.448Z",
    "type": "FCM_HTTP_V1"
}
```
