Testmail.app

https://testmail.app/docs
Admin
Testmail.app is an email testing service that provides on-the-fly email addresses and APIs (JSON and...
Tokens:30,935
Snippets:97
Trust Score:8
Update:1 year ago
Show doc for...
Tokens:
Raw
### GraphQL API Setup and Authentication

Source: https://testmail.app/docs/index

This section provides examples of how to set up and authenticate with the Testmail GraphQL API using different programming languages. It includes client setup, header configuration for API keys, and basic connection examples.

```APIDOC
## GraphQL API: Guide

### Setup and auth

This guide demonstrates how to set up and authenticate with the Testmail GraphQL API across various languages.

#### Java
```java
package com.example.example;

import java.lang.System;
import com.apollographql.apollo.ApolloCall;
import com.apollographql.apollo.ApolloClient;
import com.apollographql.apollo.api.Response;
import com.apollographql.apollo.exception.ApolloException;
import org.jetbrains.annotations.NotNull;
import com.example.FetchQuery;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging._;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import java.util._;

public class Main {

    private final static Logger LOGGER =
        Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
    public static void main(String[] args) {
        Map < String, String > headers = new HashMap < String, String > ();
        String key = 'API_KEY_HERE';
        headers.put("Authorization", "Bearer " + key);

        OkHttpClient httpClient = new OkHttpClient.Builder()
            .addInterceptor(chain -> {
                Request original = chain.request();
                Request.Builder builder = original.newBuilder().method(original.method(), original.body());
                headers.forEach(builder::header);
                return chain.proceed(builder.build());
            })
            .build();

        // First, create an `ApolloClient`
        // Replace the serverUrl with your GraphQL endpoint
        ApolloClient apolloClient = ApolloClient.builder()
            .serverUrl("https://api.testmail.app/api/graphql").okHttpClient(httpClient).build();

        // Then enqueue your query
    }
}
```

#### C#
```csharp
using GraphQL;
using GraphQL.Client.Http;
using GraphQL.Client.Serializer.Newtonsoft;
using InboxResponse;
using System.Text.Json;

var graphQLHttpClientOptions = new GraphQLHttpClientOptions
{
 EndPoint = new Uri("https://api.testmail.app/api/graphql")
};

var httpClient = new HttpClient();
string mySecret = 'API_KEY_HERE';

httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + mySecret);

var graphQLClient = new GraphQLHttpClient(graphQLHttpClientOptions, new NewtonsoftJsonSerializer(), httpClient);
```

#### Go
```go
package main

import (
  "context"
 "fmt"
 "net/http"
 "os"

 "github.com/Khan/genqlient/graphql"
)

type authedTransport struct {
  wrapped http.RoundTripper
}

func (t *authedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
  key := 'API_KEY_HERE'
  req.Header.Set("Authorization", "Bearer "+key)
  return t.wrapped.RoundTrip(req)
}


func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
client := graphql.NewClient("https://api.testmail.app/api/graphql",
    &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})
}
```

#### Python
```python
from gql import gql, Client
import json, time
from gql.transport.aiohttp import AIOHTTPTransport

# Select your transport with testmail grahql api endpoint
transport = AIOHTTPTransport(url='https://api.testmail.app/api/graphql', headers={'Authorization': 'Bearer API_KEY'})

# Create a GraphQL client using the defined transport
client = Client(transport=transport, fetch_schema_from_transport=True)
```

#### Node.js
```javascript
const GraphQLClient = require('@testmail.app/graphql-request').GraphQLClient;
const testmailClient = new GraphQLClient(
  // API endpoint:
  'https://api.testmail.app/api/graphql',
  // Use your API key:
  { headers: { Authorization: 'Bearer API_KEY' } }
);
```

#### PHP
```php
<?php
require __DIR__ . '/vendor/autoload.php';
use Softonic\GraphQL\ClientBuilder;

$APIKEY = 'YOUR_APIKEY';
$client =  ClientBuilder::build(
  'https://api.testmail.app/api/graphql',
  [
    'headers' => ['Authorization' => "Bearer $APIKEY"]
  ]
);
```

#### Ruby
```ruby
require 'graphql/client'
require 'graphql/client/http'


# Configure GraphQL endpoint using the basic HTTP network adapter.
HTTP = GraphQL::Client::HTTP.new('https://api.testmail.app/api/graphql') do
  def headers(_context)
    # Optionally set any HTTP headers
    { "Authorization": 'Bearer ' + 'YOUR_API_KEY' }
  end
end
```
```

--------------------------------

### Live Queries - Python Example

Source: https://testmail.app/docs/index

Example of performing live queries using Python with the `gql` library.

```APIDOC
## Live Queries with Python

### Description
This Python snippet demonstrates how to fetch live inbox data using the `gql` library. It constructs a GraphQL query dynamically with a timestamp and executes it against the API.

### Method
POST (via GraphQL endpoint)

### Endpoint
`https://api.testmail.app/api/graphql`

### Parameters
#### Query Variables
- **namespace** (String!) - The namespace for the inbox.
- **timestamp** (Float!) - A timestamp (Unix epoch in milliseconds) to filter emails from.

### Request Example
```python
import time
from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport

# Get the current Unix timestamp in milliseconds
timestamp = int(time.time() * 1000)

# Define the GraphQL query using an f-string to embed the timestamp
# The query fetches inbox details with livequery enabled.
query = gql(
    f"""
     {
      inbox (
        namespace:"YOUR_NAMESPACE"
        tag_prefix:"test"
        timestamp_from:{timestamp}
        livequery:true
      ) {
        result
        message
        emails {
          from
          from_parsed {
            address
            name
          }
          subject
        }
      }
     }

    """
)

# Configure the transport with the API endpoint and authentication header
# Replace YOUR_API_KEY with your actual API key
transport=RequestsHTTPTransport(
    url="https://api.testmail.app/api/graphql",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    use_json=True,
)

# Create a GraphQL client instance
client = Client(transport=transport, fetch_schema_from_transport=False)

# Execute the query
result = client.execute(query)

# Print the result
print(result)
```

### Response
#### Success Response (200)
- **inbox** (Object) - Contains the live query results for the inbox.
  - **result** (String) - Indicates the success or failure of the query.
  - **message** (String) - A message providing more details about the query result.
  - **emails** (Array) - A list of email objects matching the query criteria.

#### Response Example
```json
{
  "inbox": {
    "result": "success",
    "message": "",
    "emails": [
      {
        "from": "sender@example.com",
        "from_parsed": {
          "address": "sender@example.com",
          "name": "Sender Name"
        },
        "subject": "Test Email"
      }
    ]
  }
}
```
```

--------------------------------

### GraphQL API: Basic Setup and Bearer Token Authentication with JavaScript

Source: https://context7.com/context7/testmail_app/llms.txt

This example shows how to configure a GraphQL client for the Testmail API using `@testmail.app/graphql-request`. It demonstrates setting up the client with the API endpoint and authenticating using a Bearer token in the request headers.

```javascript
const { GraphQLClient } = require('@testmail.app/graphql-request');

const client = new GraphQLClient(
  'https://api.testmail.app/api/graphql',
  {
    headers: {
      Authorization: 'Bearer YOUR_API_KEY'
    }
  }
);

const query = `{
  inbox(namespace: "acmeinc") {
    result
    message
    count
    emails {
      from
      subject
      timestamp
    }
  }
}`;

client.request(query)
  .then(data => console.log(data.inbox))
  .catch(err => console.error(err));
```

--------------------------------

### Live Queries - Go Client Example

Source: https://testmail.app/docs/index

Example of using the genqlient library in Go to interact with the GraphQL API for live inbox queries.

```APIDOC
## Live Queries with Go Client

### Description
This Go code snippet demonstrates how to use the genqlient library to generate a strongly-typed Go client for fetching live inbox data. It includes setting up the client with authentication and making a `getInbox` call.

### Method
POST (via GraphQL endpoint)

### Endpoint
`https://api.testmail.app/api/graphql`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body (Implicit via `getInbox` function)
- **namespace** (String!) - The namespace for the inbox.
- **timestamp** (Float!) - A timestamp (Unix epoch in milliseconds) to filter emails from.

### Request Example
```go
package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	"your_module/graphql"
)

// Assume authedTransport and getInbox are defined elsewhere (generated by genqlient)
type authedTransport struct {
	wrapped http.RoundTripper
}

func (t *authedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	// Add Authorization header here
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	return t.wrapped.RoundTrip(req)
}

func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
  client := graphql.NewClient("https://api.testmail.app/api/graphql",
      &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})

  now := time.Now()      // current local time
  sec := now.UnixMicro() // Use UnixMicro for higher precision if needed, or UnixMilli

  // getInbox is a function generated by genqlient from the GraphQL schema.
  resp, err := getInbox(context.Background(), client, "YOUR_NAMESPACE", float64(sec))
  if err != nil {
    // Handle error
    return
  }
  fmt.Println(resp.Inbox)
}
```

### Response
#### Success Response (200)
- **Inbox** (Object) - Contains the live query results for the inbox.

#### Response Example
```json
{
  "result": "success",
  "message": "",
  "emails": [
    {
      "from": "sender@example.com",
      "from_parsed": {
        "address": "sender@example.com",
        "name": "Sender Name"
      },
      "subject": "Test Email"
    }
  ]
}
```
```

--------------------------------

### Fetch Emails using cURL

Source: https://testmail.app/docs/index

This example demonstrates how to fetch data from the Testmail API using the cURL command-line tool. It constructs a simple GET request with the API key and namespace as query parameters. This method is universally available on most systems with cURL installed.

```bash
# Get your apikey and namespace from the console after signup/signin\nAPIKEY="YOUR_APIKEY"\nNAMESPACE="YOUR_NAMESPACE"\n\n# Use any HTTP client (or your browser)\ncurl "https://api.testmail.app/api/json?apikey=${APIKEY}&namespace=${NAMESPACE}&pretty=true"\n
```

--------------------------------

### Live Queries - PHP Example

Source: https://testmail.app/docs/index

Example of performing live queries using PHP with a GraphQL client.

```APIDOC
## Live Queries with PHP

### Description
This PHP snippet shows how to execute a live query to fetch emails from an inbox using a GraphQL client. It defines the query, sets the necessary variables (namespace, tag prefix, timestamp), and processes the response.

### Method
POST (via GraphQL endpoint)

### Endpoint
`https://api.testmail.app/api/graphql`

### Parameters
#### Query Variables
- **namespace** (String!) - The namespace for the inbox.
- **timestamp** (Float!) - A timestamp (Unix epoch in milliseconds) to filter emails from.

### Request Example
```php
<?php

// Assume $client is an initialized GraphQL client instance

$query = <<<'QUERY'
query GetMails($timestamp: Float) {
  inbox (
      namespace:"YOUR_NAMESPACE"
      tag_prefix:"test"
      timestamp_from:$timestamp
      livequery:true
  ) {
    result
    message
    emails {
      from
      from_parsed {
        address
        name
      }
      subject
    }
  }
}
QUERY;

$variables = [
  "timestamp" => time() * 1000 // Current Unix timestamp in milliseconds
];

$response = $client->query($query, $variables);
$r =  $response->getData();

echo "<pre>".json_encode($r, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)."</pre>";

?>
```

### Response
#### Success Response (200)
- **data** (Object) - Contains the live query results for the inbox.

#### Response Example
```json
{
  "result": "success",
  "message": "",
  "emails": [
    {
      "from": "sender@example.com",
      "from_parsed": {
        "address": "sender@example.com",
        "name": "Sender Name"
      },
      "subject": "Test Email"
    }
  ]
}
```
```

--------------------------------

### GraphQL API Setup and Authentication

Source: https://testmail.app/docs/index

Demonstrates how to set up and authenticate with the GraphQL API across multiple programming languages. This involves configuring the API endpoint and setting the 'Authorization' header with your API key. Dependencies include specific GraphQL client libraries for each language.

```java
package com.example.example;

import java.lang.System;
import com.apollographql.apollo.ApolloCall;
import com.apollographql.apollo.ApolloClient;
import com.apollographql.apollo.api.Response;
import com.apollographql.apollo.exception.ApolloException;
import org.jetbrains.annotations.NotNull;
import com.example.FetchQuery;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging._;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import java.util._;

public class Main {

    private final static Logger LOGGER =
        Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
    public static void main(String[] args) {
        Map < String, String > headers = new HashMap < String, String > ();
        String key = 'API_KEY_HERE';
        headers.put("Authorization", "Bearer " + key);

        OkHttpClient httpClient = new OkHttpClient.Builder()
            .addInterceptor(chain -> {
                Request original = chain.request();
                Request.Builder builder = original.newBuilder().method(original.method(), original.body());
                headers.forEach(builder::header);
                return chain.proceed(builder.build());
            })
            .build();

        // First, create an `ApolloClient`
        // Replace the serverUrl with your GraphQL endpoint
        ApolloClient apolloClient = ApolloClient.builder()
            .serverUrl("https://api.testmail.app/api/graphql").okHttpClient(httpClient).build();

        // Then enqueue your query
    }
}

```

```csharp
using GraphQL;
using GraphQL.Client.Http;
using GraphQL.Client.Serializer.Newtonsoft;
using InboxResponse;
using System.Text.Json;

var graphQLHttpClientOptions = new GraphQLHttpClientOptions
{
EndPoint = new Uri("https://api.testmail.app/api/graphql")
};

var httpClient = new HttpClient();
string mySecret = 'API_KEY_HERE';

httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + mySecret);

var graphQLClient = new GraphQLHttpClient(graphQLHttpClientOptions, new NewtonsoftJsonSerializer(), httpClient);

```

```go
package main

import (
  "context"
 "fmt"
 "net/http"
 "os"

  "github.com/Khan/genqlient/graphql"
)

type authedTransport struct {
  wrapped http.RoundTripper
}

func (t *authedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
  key := 'API_KEY_HERE'
  req.Header.Set("Authorization", "Bearer "+key)
  return t.wrapped.RoundTrip(req)
}


func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
client := graphql.NewClient("https://api.testmail.app/api/graphql",
    &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})
}

```

```python
from gql import gql, Client
import json, time
from gql.transport.aiohttp import AIOHTTPTransport

# Select your transport with testmail grahql api endpoint
transport = AIOHTTPTransport(url='https://api.testmail.app/api/graphql', headers={'Authorization': 'Bearer API_KEY'})

# Create a GraphQL client using the defined transport
client = Client(transport=transport, fetch_schema_from_transport=True)

```

```javascript
const GraphQLClient = require('@testmail.app/graphql-request').GraphQLClient;
const testmailClient = new GraphQLClient(
  // API endpoint:
  'https://api.testmail.app/api/graphql',
  // Use your API key:
  { headers: { Authorization: 'Bearer API_KEY' } }
);

```

```php
<?php
require __DIR__ . '/vendor/autoload.php';
use Softonic\GraphQL\ClientBuilder;

$APIKEY = 'YOUR_APIKEY';
$client =  ClientBuilder::build(
  'https://api.testmail.app/api/graphql',
  [
    'headers' => ['Authorization' => "Bearer $APIKEY"]
  ]
);


```

```ruby
require 'graphql/client'
require 'graphql/client/http'


# Configure GraphQL endpoint using the basic HTTP network adapter.
HTTP = GraphQL::Client::HTTP.new('https://api.testmail.app/api/graphql') do
  def headers(_context)
    # Optionally set any HTTP headers
    { "Authorization": 'Bearer ' + 'YOUR_API_KEY' }
  end
end


```

--------------------------------

### Fetch Inbox Details using Go (genqlient)

Source: https://testmail.app/docs/index

Example of fetching inbox details using the genqlient library in Go. This involves setting up a client with authentication and calling the generated query function.

```go
// create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
client := graphql.NewClient("https://api.testmail.app/api/graphql",
    &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})

// getInbox is a function generated by genqlient from the GraphQL schema.
resp, err := getInbox(context.Background(), client, "YOUR_NAMESPACE")
if err != nil {
  return
}
fmt.Println(resp.Inbox)
```

--------------------------------

### Live Queries - GraphQL.NET Example

Source: https://testmail.app/docs/index

Example of using GraphQL.NET client to perform live queries for inbox data.

```APIDOC
## Live Queries with GraphQL.NET

### Description
This C# example demonstrates using the `GraphQL.Client` library in .NET to send a query for live inbox data. It shows how to construct the GraphQL request with variables and handle the response.

### Method
POST (via GraphQL endpoint)

### Endpoint
`https://api.testmail.app/api/graphql`

### Parameters
#### Query Variables
- **namespace** (String!) - The namespace for the inbox.
- **tag** (String!) - A tag to filter emails.
- **timestamp** (Float!) - A timestamp (Unix epoch in milliseconds) to filter emails from.

### Request Example
```csharp
// Assume graphQLClient is an initialized GraphQLHttpClient instance
// Assume InboxType is a C# class representing the expected response structure

// Get the current time in milliseconds since epoch
long unixTimestamp = 1000 * (long)(DateTime.Now.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;

var inboxRequest = new GraphQLRequest
{
    Query = @"
        query getInbox($namespace : String!,$tag : String!, $timestamp : Float!){
            inbox (
                   namespace:$namespace
                   tag_prefix:$tag
                   timestamp_from:$timestamp
                   livequery:true
          ) {
            result
            message
            emails {
              from
              from_parsed {
                address
                name
              }
              subject
            }
          }
        }
    ",
    Variables = new {
        Tag = "john.smith",
        Namespace = "YOUR_NAMESPACE",
        Timestamp = unixTimestamp
    }
};

// Send the query asynchronously and deserialize the response into InboxType
var graphQLResponse = await graphQLClient.SendQueryAsync<InboxType>(inboxRequest);

// Serialize the response data to JSON for pretty printing
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(graphQLResponse.Data, new JsonSerializerOptions { WriteIndented = true }));
```

### Response
#### Success Response (200)
- **Data** (InboxType) - The deserialized response object containing inbox details.

#### Response Example
```json
{
  "result": "success",
  "message": "",
  "emails": [
    {
      "from": "sender@example.com",
      "from_parsed": {
        "address": "sender@example.com",
        "name": "Sender Name"
      },
      "subject": "Test Email"
    }
  ]
}
```
```

--------------------------------

### GraphQL Query Examples

Source: https://testmail.app/docs/index

Examples of GraphQL queries for fetching inbox details with various filtering and sorting options using different client libraries.

```APIDOC
## GraphQL Query Examples

### Description
This section provides examples of how to construct and execute GraphQL queries to fetch inbox details, demonstrating different client implementations and advanced filtering/sorting capabilities.

### Client Library Examples:

#### 1. PHP Example (using a hypothetical client)
```php
<?php

// Assume $client is an authenticated GraphQL client instance

$query = <<<'QUERY'
{
inbox (
    namespace:"YOUR_NAMESPACE"
    tag_prefix:"peter"
    advanced_filters:[{
      field:subject
      match:exact
      action:include
      value:"Please confirm your email"
    }]
    advanced_sorts:[{
      field:tag,
      order:asc
    }, {
      field:timestamp,
      order:desc
    }]
  ) {
    result
    message
    count
    emails {
      tag
      timestamp
    }
  }
}
QUERY;

$variables = [];

$response = $client->query($query, $variables);
$r =  $response->getData();

// Output the response
echo "<pre>".json_encode($r, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)."</pre>";

?>
```

#### 2. Java Example (using Apollo Client)
```java
// Assume FetchQuery is a generated class from your GraphQL schema
// Assume apolloClient is an initialized ApolloClient instance

apolloClient.query(new FetchQuery("NAMESPACE_HERE", "TAG_HERE", "SUBJECT_HERE"))
.enqueue(new ApolloCall.Callback < FetchQuery.Data > () {
  @Override
  public void onResponse(@NotNull Response < FetchQuery.Data > response) {
    LOGGER.log(Level.INFO, "Output: " + response.getData());
  }

  @Override
  public void onFailure(@NotNull ApolloException e) {
      LOGGER.log(Level.INFO, "Error", e);
  }
});
```

#### 3. Go Example (using genqlient)
```go
// Assume authedTransport is a custom http.RoundTripper that adds auth headers
// Assume getInbox is a function generated by genqlient

func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
  client := graphql.NewClient("https://api.testmail.app/api/graphql",
      &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})

  // getInbox is a function generated by genqlient from the GraphQL schema.
  resp, err := getInbox(context.Background(), client, "YOUR_NAMESPACE")
  if err != nil {
    // Handle error
    return
  }
  fmt.Println(resp.Inbox)
}
```

#### 4. Python Example (using gql)
```python
from gql import gql

# Assume gql is imported and a client is set up

query = gql(
    """
      {
        inbox (
          namespace:"YOUR_NAMESPACE"
          tag_prefix:"peter"
          advanced_filters:[{
            field:subject
            match:exact
            action:include
            value:"Please confirm your email"
          }]
          advanced_sorts:[{
            field:tag,
            order:asc
          }, {
            field:timestamp,
            order:desc
          }]
          ) {
            result
            message
            count
            emails {
              tag
              timestamp
            }
          }
      }

    """
)

# Execute the query using your client
# result = client.execute(query)
```

### Notes
- Replace placeholders like `YOUR_API_KEY`, `YOUR_NAMESPACE`, etc., with your actual credentials and values.
- The specific client library syntax may vary. Refer to the respective library's documentation for details.
- Ensure your GraphQL schema is available and correctly configured for code generation when using tools like Apollo Client or genqlient.
```

--------------------------------

### JavaScript (Node.js) Live Query for New Emails

Source: https://testmail.app/docs/index

This JavaScript example for Node.js shows how to fetch new emails using the Testmail.app API with the `livequery=true` option. It uses the `axios` library to make an asynchronous GET request. Ensure you provide your valid API key and namespace.

```javascript
// Use any HTTP client
const res = await axios.get('https://api.testmail.app/api/json', {
  params: {
    apikey: 'YOUR_APIKEY',
    namespace: 'YOUR_NAMESPACE',
    livequery: 'true'
  }
});
console.log(res.data);
```

--------------------------------

### GraphQL API: Basic Setup and Authentication

Source: https://context7.com/context7/testmail_app/llms.txt

Configure a GraphQL client with bearer token authentication for accessing the Testmail.app GraphQL API.

```APIDOC
## GraphQL API: Basic Setup and Authentication

### Description
Configure a GraphQL client with bearer token authentication.

### Method
POST

### Endpoint
https://api.testmail.app/api/graphql

### Parameters
#### Headers
- **Authorization** (string) - Required - Bearer token authentication (e.g., 'Bearer YOUR_API_KEY').

### Request Body
- **query** (string) - Required - The GraphQL query string.

### Request Example
```javascript
const { GraphQLClient } = require('@testmail.app/graphql-request');

const client = new GraphQLClient(
  'https://api.testmail.app/api/graphql',
  {
    headers: {
      Authorization: 'Bearer YOUR_API_KEY'
    }
  }
);

const query = `{ 
  inbox(namespace: "acmeinc") { 
    result
    message
    count
    emails {
      from
      subject
      timestamp
    }
  }
}`;

client.request(query)
  .then(data => console.log(data.inbox))
  .catch(err => console.error(err));
```

### Response
#### Success Response (200)
- **result** (string) - Indicates the success of the operation ('success').
- **message** (string|null) - A message related to the operation.
- **count** (integer) - The number of emails returned.
- **emails** (array) - An array of email objects (structure depends on the query).

#### Response Example
```json
{
  "result": "success",
  "message": null,
  "count": 2
}
```
```

--------------------------------

### Fetch Inbox with Live Query using Python

Source: https://testmail.app/docs/index

This Python example demonstrates fetching inbox data with live query enabled using the gql library. It constructs the query dynamically with a namespace, tag prefix, and a Unix timestamp. The response data is then printed.

```python
timestamp = int(time.time() * 1000)

# Provide the query to fetch inbox details with livequery as true.
query = gql(
    f"""
     {{
      inbox (
        namespace:"YOUR_NAMESPACE"
        tag_prefix:"test"
        timestamp_from:{timestamp}
        livequery:true
      ) {{
        result
        message
        emails {{
          from
          from_parsed {{
            address
            name
          }}
          subject
        }}
      }}
     }}

    """
)


```

--------------------------------

### Fetch Emails using Python Requests

Source: https://testmail.app/docs/index

This Python script utilizes the `requests` library to interact with the Testmail API. It defines the API endpoint and parameters, then sends a GET request. The response is parsed as JSON and pretty-printed to the console. Make sure to install the library: `pip install requests`.

```python
import os\nimport json\nimport requests\nAPI_KEY = 'API_KEY_HERE'\n\n# api-endpoint\nURL = "https://api.testmail.app/api/json"\n\n# defining a params dict for the parameters to be sent to the API\nPARAMS = {'apikey':API_KEY, 'namespace':'YOUR_NAMESPACE'}\n\n# sending get request and saving the response as response object\nr = requests.get(url = URL, params = PARAMS)\n\n# extracting data in json format\ndata = r.json()\nprint(json.dumps(data, indent=4))\n
```

--------------------------------

### Live Queries - Apollo Android Example

Source: https://testmail.app/docs/index

Example of using Apollo Android client to fetch live inbox data with specified tags and timestamps.

```APIDOC
## Live Queries with Apollo Android

### Description
This example shows how to use the Apollo Android GraphQL client to fetch live inbox data. It demonstrates defining the query, setting variables, and handling the response and potential errors.

### Method
POST (via GraphQL endpoint)

### Endpoint
`https://api.testmail.app/api/graphql`

### Parameters
#### Query Variables
- **namespace** (String!) - The namespace for the inbox.
- **tag** (String!) - A tag to filter emails.
- **timestamp** (Float!) - A timestamp (Unix epoch in milliseconds) to filter emails from.

### Request Example
```java
// Assume FetchQuery.java is generated by Apollo from the GraphQL schema
// Assume apolloClient is an initialized ApolloClient instance

// Get the current time in milliseconds
long unixTime = System.currentTimeMillis();

apolloClient.query(new FetchQuery("NAMESPACE_HERE", "TAG_HERE", unixTime))
.enqueue(new ApolloCall.Callback < FetchQuery.Data > () {
  @Override
  public void onResponse(@NotNull Response < FetchQuery.Data > response) {
    // Log the data, which contains the inbox results
    LOGGER.log(Level.INFO, "Output: " + response.getData());
  }

  @Override
  public void onFailure(@NotNull ApolloException e) {
      // Log any errors that occur during the request
      LOGGER.log(Level.INFO, "Error", e);
  }
});
```

### Response
#### Success Response (200)
- **data** (FetchQuery.Data) - The response data object containing inbox details.

#### Response Example
```json
{
  "data": {
    "inbox": {
      "result": "success",
      "message": "",
      "emails": [
        {
          "from": "sender@example.com",
          "from_parsed": {
            "address": "sender@example.com",
            "name": "Sender Name"
          },
          "subject": "Test Email"
        }
      ]
    }
  }
}
```
```

--------------------------------

### Fetch Inbox with Live Query using Go (genqlient)

Source: https://testmail.app/docs/index

This Go example utilizes the genqlient library to create a strongly-typed GraphQL client. It demonstrates fetching inbox data with live query enabled, including email details like 'from', 'from_parsed', and 'subject'. Requires a namespace and a timestamp.

```go
/*
  * This example uses the genqlient library to generate a strongly-typed Go client
  * from the GraphQL schema.
  * The genqlient.schema file is contains the following schema:

    query getInbox($namespace : String!, $timestamp : Float!){
      inbox (
          namespace:$namespace
          tag:"john.smith"
          timestamp_from:$timestamp
          livequery:true
        ) {
            result
            message
            emails {
              from
              from_parsed {
                address
                name
              }
              subject
            }
          }
      }
*/


func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
  client := graphql.NewClient("https://api.testmail.app/api/graphql",
      &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})

  now := time.Now()      // current local time
  sec := now.UnixMicro()

  // getInbox is a function generated by genqlient from the GraphQL schema.
  resp, err := getInbox(context.Background(), client, "YOUR_NAMESPACE", float64(sec))
  if err != nil {
    return
  }
  fmt.Println(resp.Inbox)
}


```

--------------------------------

### Java Live Query for New Emails

Source: https://testmail.app/docs/index

This Java example shows how to implement a live query for new emails using the Testmail.app API. It employs the `java.net.http.HttpClient` to send a request with the `livequery=true` parameter. Remember to substitute your actual API key and namespace.

```java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class Main {
public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
// create a client
var client = HttpClient.newHttpClient();
String APIKEY = "YOUR_APIKEY", NAMESPACE = "YOUR_NAMESPACE";
var url = "https://api.testmail.app/api/json?apikey=" + APIKEY + "&namespace=" + NAMESPACE + "&pretty=true&livequery=true";
// create a request
var request = HttpRequest.newBuilder(URI.create(url))
        .header("accept", "application/json")
        .build();

        // use the client to send the request
        var response = client.send(request, HttpResponse.BodyHandlers.ofString());

        // the response:
        System.out.println(response.body());

    }

}
```

--------------------------------

### Fetch Emails using Go net/http

Source: https://testmail.app/docs/index

This Go program demonstrates how to fetch data from the Testmail API using the standard `net/http` package. It constructs the URL with query parameters, makes an HTTP GET request, reads the response body, and logs it. This code is self-contained and does not require external libraries.

```go
package main\n\nimport (\n  "os"\n "io/ioutil"\n "log"\n "net/http"\n  "net/url"\n)\n\nfunc main() {\n  key := 'API_KEY_HERE'\n  // Define the parameters\n    params := url.Values{}\n    params.Add("apikey", key)\n    params.Add("namespace", "YOUR_NAMESPACE")\n\n    // Create the URL with the parameters\n    url := "https://api.testmail.app/api/json?" + params.Encode()\n\n   resp, err := http.Get(url)\n   if err != nil {\n      log.Fatalln(err)\n   }\n//We Read the response body on the line below.\n   body, err := ioutil.ReadAll(resp.Body)\n   if err != nil {\n      log.Fatalln(err)\n   }\n//Convert the body to type string\n   sb := string(body)\n   log.Printf(sb)\n}\n\n
```

--------------------------------

### Fetch Inbox with Live Query using C#

Source: https://testmail.app/docs/index

This C# example demonstrates fetching inbox data with live query enabled using a GraphQL client. It constructs the query and variables, including namespace, tag prefix, and a Unix timestamp. The response data is then serialized to JSON.

```csharp
long unixTimestamp = 1000 * (long)(DateTime.Now.Subtract(new
      DateTime(1970, 1, 1))).TotalSeconds;

var inboxRequest = new GraphQLRequest
{
    Query = @"
        query getInbox($namespace : String!,$tag : String!, $timestamp : Float!){
            inbox (
                   namespace:$namespace
                   tag_prefix:$tag
                   timestamp_from:$timestamp
                   livequery:true
          ) {
            result
            message
            emails {
              from
              from_parsed {
                address
                name
              }
              subject
            }
          }
        }
    ",
    Variables = new { 
        Tag = "john.smith",
        Namespace = "YOUR_NAMESPACE",
        Timestamp = unixTimestamp
    }
};

var graphQLResponse = await graphQLClient.SendQueryAsync<InboxType>(inboxRequest);
  Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(graphQLResponse.Data, new JsonSerializerOptions { WriteIndented = true }));



```

--------------------------------

### Fetch Inbox Details using Java (Apollo Android)

Source: https://testmail.app/docs/index

Example of querying inbox details using the Apollo Android client. This requires setting up the Apollo client and handling responses and errors.

```java
/**
 * The following GraphQL query should be present in a graphql file along with the schema.
  query FetchQuery($namespace: String!, $tag: String!) {
    inbox(namespace: $namespace, tag_prefix: $tag) {
      result
      message
      count
    }
  }
 *
 */

apolloClient.query(new FetchQuery("NAMESPACE_HERE", "TAG_HERE"))
.enqueue(new ApolloCall.Callback < FetchQuery.Data > () {
  @Override
  public void onResponse(@NotNull Response < FetchQuery.Data > response) {
    LOGGER.log(Level.INFO, "Output: " + response.getData());
  }

  @Override
  public void onFailure(@NotNull ApolloException e) {
      LOGGER.log(Level.INFO, "Error", e);
  }
});
```

--------------------------------

### Fetch Inbox with Advanced Filters and Sorting (Go/genqlient)

Source: https://testmail.app/docs/index

This Go example uses the genqlient library to interact with the Testmail App GraphQL API. It defines a query for fetching inbox details with specific filters and sorting. A client is created with an authenticated transport, and the `getInbox` function is called.

```graphql
query getInbox($namespace : String!){
  inbox (
    namespace:$namespace
    tag_prefix:"peter"
    advanced_filters:[{
      field:subject
      match:exact
      action:include
      value:"Please confirm your email"
    }]
    advanced_sorts:[{
      field:tag,
      order:asc
    }, { 
      field:timestamp,
      order:desc
    }]
    ) {
      result
      message
      count
      emails {
        tag
        timestamp
      }
    }
 }
```

```go
func main() {
  // create a client (safe to share across requests) by passing in an HTTP client that adds the auth header
  client := graphql.NewClient("https://api.testmail.app/api/graphql",
      &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}})

  // getInbox is a function generated by genqlient from the GraphQL schema.
  resp, err := getInbox(context.Background(), client, "YOUR_NAMESPACE")
  if err != nil {
    return
  }
  fmt.Println(resp.Inbox)
}


```

--------------------------------

### Go genqlient: Query Inbox Emails

Source: https://context7.com/context7/testmail_app/llms.txt

A strongly-typed Go client for GraphQL queries using the genqlient library. It sets up an authenticated HTTP client and executes a query to retrieve inbox emails. Requires the genqlient library to be installed.

```go
package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
    "github.com/Khan/genqlient/graphql"
)

type authedTransport struct {
    wrapped http.RoundTripper
}

func (t *authedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    key := "YOUR_API_KEY"
    req.Header.Set("Authorization", "Bearer "+key)
    return t.wrapped.RoundTrip(req)
}

func main() {
    client := graphql.NewClient(
        "https://api.testmail.app/api/graphql",
        &http.Client{Transport: &authedTransport{wrapped: http.DefaultTransport}},
    )

    now := time.Now()
    timestamp := float64(now.UnixMilli())

    // getInbox is generated by genqlient from schema
    resp, err := getInbox(context.Background(), client, "acmeinc", timestamp)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Result: %s, Count: %d\n", resp.Inbox.Result, resp.Inbox.Count)
    for _, email := range resp.Inbox.Emails {
        fmt.Printf("From: %s - Subject: %s\n", email.From, email.Subject)
    }
}
```

--------------------------------

### Fetch Inbox with Live Query using PHP

Source: https://testmail.app/docs/index

This PHP example shows how to fetch inbox data with live query enabled. It defines the GraphQL query and variables, including namespace, tag prefix, and a Unix timestamp. The response is then encoded as pretty-printed JSON.

```php
$query = <<<'QUERY'
query GetMails($timestamp: Float) {
  inbox (
      namespace:"YOUR_NAMESPACE"
      tag_prefix:"test"
      timestamp_from:$timestamp
      livequery:true
  ) {
    result
    message
    emails {
      from
      from_parsed {
        address
        name
      }
      subject
    }
  }
}
QUERY;

$variables = [
  "timestamp" => time() * 1000
];

$response = $client->query($query, $variables);
$r =  $response->getData();
echo "<pre>".json_encode($r, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)."</pre>";

?>


```

--------------------------------

### Ruby GraphQL API Client for Testmail.app

Source: https://context7.com/context7/testmail_app/llms.txt

This Ruby code snippet demonstrates how to set up and use the graphql-client library to query the Testmail.app GraphQL API. It includes authentication, schema loading, query parsing, and handling email data. The example highlights the use of live queries to fetch new emails.

```ruby
require 'graphql/client'
require 'graphql/client/http'

HTTP = GraphQL::Client::HTTP.new('https://api.testmail.app/api/graphql') do
  def headers(_context)
    { "Authorization": 'Bearer YOUR_API_KEY' }
  end
end

Schema = GraphQL::Client.load_schema(HTTP)
Client = GraphQL::Client.new(schema: Schema, execute: HTTP)

EmailQuery = Client.parse <<-'GRAPHQL'
  query($timestamp: Float) {
    inbox(
      namespace: "acmeinc"
      tag_prefix: "test"
      timestamp_from: $timestamp
      livequery: true
    ) {
      result
      count
      emails {
        from
        from_parsed {
          address
          name
        }
        subject
        text
      }
    }
  }
GRAPHQL

timestamp = Time.now.to_i * 1000
result = Client.query(EmailQuery, variables: { timestamp: timestamp })

puts "Result: #{result.data.inbox.result}"
puts "Count: #{result.data.inbox.count}"

result.data.inbox.emails.each do |email|
  puts "From: #{email.from_parsed.name} <#{email.from_parsed.address}>"
  puts "Subject: #{email.subject}"
  puts "---"
end

```
Tokens:
Raw