> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://tc.docs.syndicate.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://tc.docs.syndicate.io/_mcp/server.

# Sign Typed Data With Lookup

POST https://api.syndicate.io/wallet/project/{projectId}/signTypedDataWithLookup
Content-Type: application/json

Sign EIP712 compliant typed data after asserting all lookups are valid. Lookups can be view or pure functions on smart contracts. Responses are compared to specified values in the request.

Reference: https://tc.docs.syndicate.io/api/signatures/sign-typed-data-with-lookup

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `projectId` (UUID, required)

### Body (application/json)

This endpoint expects a SignTypedDataWithLookupRequest.

- `domain` (EIP712Domain, required) — Components of the [domain seperator](https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator). At least one field is required.
- `lookups` (set of ContractLookup, required) — Specify a maximum of 5 contract lookups to compare data with. All lookups must be valid to receive a signature by the 'signerAddress'.
- `message` (map from string to any, required) — Data to be signed by the 'signerAddress'. The message's structure must be correctly defined in the 'types' mapping, specified by the 'primaryType'.
- `primaryType` (string, required) — Specifies the name of the key in 'types' that describes the shape of the 'message'.
- `signerAddress` (string, required) — Address of a project wallet that will be used to sign the 'message'.
- `types` (map from string to set of EIP712Types, required) — Type definitions of the domain and data you are requesting signature of. At minimum you must define the domain with key 'EIP712Domain' and the type of your message with key specified by 'primaryType'. More information [here](https://eips.ethereum.org/EIPS/eip-712#definition-of-typed-structured-data-%F0%9D%95%8A).
- `signatureId` (UUID, optional) — (Optional) ID of the request. Needs to be a valid UUID. If provided, it will be saved and returned as the signatureId of the response. If not provided, we will generate one for you and return it as the signatureId.

## Response

### 200

- `message` (any, required) — The raw data requested to be signed.
- `signature` (string, required) — The signature of 'message' by the 'signerAddress'.
- `signerAddress` (string, required) — The address of the signer of the 'signature'.
- `signatureId` (UUID, required) — UUID of the signature request.

## Errors

### 400 Signature Error

- `message` (string, required)

### 500 Internal Error

- `message` (string, required)

## Types

### EIP712Domain

- `chainId` (integer, required)
- `name` (string, optional)
- `version` (string, optional)
- `verifyingContract` (string, optional)
- `salt` (string, optional)

### ContractLookup

Specify a pure or view function on a contract at 'contractAddress' on a specific 'chainId' to read data from. 'args' are optional, but must be passed if specified in the human readable 'functionSignature'

- `chainId` (integer, required) — The chain ID for the network (e.g. 1 for Ethereum Mainnet, 137 for Polygon Mainnet, 80001 for Polygon Mumbai). For a complete list of chain IDs, see [ChainList](https://chainlist.org/?search=&testnets=true).
- `contractAddress` (string, required) — The contract address to send request to
- `functionSignature` (string, required) — The human readable signature to call on the contract
- `operation` (enum, required)
  - Allowed values: `eq`, `gt`, `lt`
- `type` (enum, required)
  - Allowed values: `contract`
- `value` (string, required)
- `args` (map from string to any, optional) — (Optional) The function arguments for the read contract call. The keys are the argument names or index from the provided 'functionSignature' and the values are the argument values.

### EIP712Types

- `name` (string, required)
- `type` (string, required)

## Examples

**Request**

```json
{
  "lookups": [
    {
      "chainId": 1,
      "contractAddress": "contractAddress",
      "functionSignature": "functionSignature",
      "type": "contract"
    }
  ]
}
```

**Response**

```json
{
  "message": {
    "key": "value"
  },
  "signature": "signature",
  "signerAddress": "signerAddress",
  "signatureId": "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32"
}
```

**SDK Code**

```python
import requests

url = "https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup"

payload = { "lookups": [
        {
            "chainId": 1,
            "contractAddress": "contractAddress",
            "functionSignature": "functionSignature",
            "type": "contract"
        }
    ] }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"lookups":[{"chainId":1,"contractAddress":"contractAddress","functionSignature":"functionSignature","type":"contract"}]}'
};

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

```go
package main

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

func main() {

	url := "https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup"

	payload := strings.NewReader("{\n  \"lookups\": [\n    {\n      \"chainId\": 1,\n      \"contractAddress\": \"contractAddress\",\n      \"functionSignature\": \"functionSignature\",\n      \"type\": \"contract\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"lookups\": [\n    {\n      \"chainId\": 1,\n      \"contractAddress\": \"contractAddress\",\n      \"functionSignature\": \"functionSignature\",\n      \"type\": \"contract\"\n    }\n  ]\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"lookups\": [\n    {\n      \"chainId\": 1,\n      \"contractAddress\": \"contractAddress\",\n      \"functionSignature\": \"functionSignature\",\n      \"type\": \"contract\"\n    }\n  ]\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup', [
  'body' => '{
  "lookups": [
    {
      "chainId": 1,
      "contractAddress": "contractAddress",
      "functionSignature": "functionSignature",
      "type": "contract"
    }
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"lookups\": [\n    {\n      \"chainId\": 1,\n      \"contractAddress\": \"contractAddress\",\n      \"functionSignature\": \"functionSignature\",\n      \"type\": \"contract\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["lookups": [
    [
      "chainId": 1,
      "contractAddress": "contractAddress",
      "functionSignature": "functionSignature",
      "type": "contract"
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.syndicate.io/wallet/project/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32/signTypedDataWithLookup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```