> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://api.docs.modulards.com/modular-ds-public-api/websites/connection/reveal-a-website-s-manual-connection-secret/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.docs.modulards.com/_mcp/server.

# Reveal a website's manual connection secret

GET https://api.modulards.com/api/public/v1/sites/{site_id}/connection/manual/reveal

Delivers the secret of a website's manual connection. This is the only response that reveals it. Do not build the URL by hand: follow the `reveal_url` returned by "Retrieve a website's manual connection credentials" exactly as it is, since it is a signed link that carries the parameters below.

This request needs no token: the signed link is the credential and `Authorization` is ignored. The link works once, however soon it is opened, and it expires. The member who requested it must still be allowed to read the secret when the link is opened, and every read is recorded in the organization's activity.

**Errors**
- **403**: the signature is invalid, altered or expired ("Invalid signature."), or the link was already used ("This link has already been used or has expired.").
- **404**: the member lost access to the organization, or the permission to connect websites, after the link was issued.

Reference: https://api.docs.modulards.com/modular-ds-public-api/websites/connection/reveal-a-website-s-manual-connection-secret

## Request

### Path parameters

- `site_id` (string, required)

### Query parameters

- `user` (string, optional) — Id of the member who requested the link. Part of the signature: never edit it.
- `nonce` (string, optional) — Single-use token bound to that member. It is spent on the first successful read.
- `origin` (string, optional) — Where the link was issued, `public` or `mcp`. It is recorded with the read and is part of the signature.
- `expires` (string, optional) — Unix timestamp until which the signature is valid.
- `signature` (string, optional) — Signature over the path and the parameters above. Never edit it.

## Response

### 200

200 - Client secret revealed

- `jsonapi` (ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaJsonapi, optional)
- `meta` (ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaMeta, optional)

## Errors

### 403 Forbidden Error

403 - Link already used or expired

- `errors` (list of ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaErrorsItems, optional)
- `jsonapi` (ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaJsonapi, optional)

## Types

### ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaMeta

- `client_id` (string, optional) — Public identifier of the website's connection credentials.
- `client_secret` (string, optional) — Secret to enter in the Modular Connector plugin. It is shown only through this single-use link.

### ApiPublicV1SitesSiteIdConnectionManualRevealGetResponsesContentApplicationJsonSchemaErrorsItems

- `detail` (string, optional)
- `status` (string, optional)
- `title` (string, optional)

## Examples

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "client_id": "a1b2c3d4-e5f6-4789-a012-b3c4d5e6f789",
    "client_secret": "8f14e45fceea167a5a36dedd4bea2543a2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e"
  }
}
```

**SDK Code**

```python 200 - Client secret revealed
import requests

url = "https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal"

response = requests.get(url)

print(response.json())
```

```javascript 200 - Client secret revealed
const url = 'https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200 - Client secret revealed
package main

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

func main() {

	url := "https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200 - Client secret revealed
require 'uri'
require 'net/http'

url = URI("https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

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

```java 200 - Client secret revealed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal")
  .asString();
```

```php 200 - Client secret revealed
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal');

echo $response->getBody();
```

```csharp 200 - Client secret revealed
using RestSharp;

var client = new RestClient("https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift 200 - Client secret revealed
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/sites/site_id/connection/manual/reveal")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```