# API Documentation

Everything you need to interact with AccessGrid.

## Programming Languages

- Terminal
- JavaScript
- Ruby
- GO
- Python
- C#
- Java
- php
- Elixir

## Read Event Log

Enterprise only

Copy for LLMCopied

Only available for enterprise customers - allows you to read full event log for a given card template, including which passes were issued, how and by whom using our console API.

### card_template_id

nullable string

Unique identifier for the card template to look up

### filters

nullable object

Filters to reduce result size of event logs

#### device

nullable string

Must be either `mobile` or `watch`

#### start_date

nullable datetime

Must be in ISO8601 format

#### end_date

nullable datetime

Must be in ISO8601 format

#### event_type

nullable string

Must be either `issue`, `install`, `update`, `suspend`, `resume`, or `unlink`

### Request

```bash
# Build the JSON payload
TEMPLATE_ID="0xd3adb00b5"
PAYLOAD="{\"id\":\"$TEMPLATE_ID\"}"

# Sign the payload
PAYLOAD_B64=$(printf '%s' "$PAYLOAD" | openssl base64 -A)
SIG=$(printf '%s' "$PAYLOAD_B64" | openssl dgst -sha256 -hmac "$SECRET_KEY" -hex | awk '{print $NF}')

curl -v -G \
-H "X-ACCT-ID: $ACCOUNT_ID" \
-H "X-PAYLOAD-SIG: $SIG" \
--data-urlencode "sig_payload=$PAYLOAD" \
"https://api.accessgrid.com/v1/console/card-templates/$TEMPLATE_ID/logs"
```

```ruby
require 'accessgrid'

acct_id = ENV['ACCOUNT_ID']
secret_key = ENV['SECRET_KEY']

client = AccessGrid.new(acct_id, secret_key)

events = client.console.event_log(
card_template_id: "0xd3adb00b5",
filters: {
device: "mobile",
start_date: 30.days.ago.utc.iso8601(3),
end_date: Time.zone.now.utc.iso8601(3),
event_type: "install"
}
)

events.each do |event|
puts "Event: #{event.type} at #{event.timestamp} by #{event.user_id}"
done
```

```javascript
import AccessGrid from 'accessgrid';

const accountId = process.env.ACCOUNT_ID;
const secretKey = process.env.SECRET_KEY;

const client = new AccessGrid(accountId, secretKey);

const getEventLog = async () => {
try {
const events = await client.console.eventLog({
     cardTemplateId: "0xd3adb00b5",
     filters: {
       device: "mobile",
       startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
       endDate: new Date().toISOString(),
       eventType: "install"
     }
});

events.forEach(event => {
     console.log(`Event: ${event.type} at ${event.timestamp} by ${event.userId}`);
});
} catch (error) {
console.error('Error fetching event log:', error);
}
};

getEventLog();
```

```python
from accessgrid import AccessGrid
import os
from datetime import datetime, timezone, timedelta

account_id = os.getenv('ACCOUNT_ID')
secret_key = os.getenv('SECRET_KEY')

client = AccessGrid(account_id, secret_key)

start_date = (datetime.now(timezone.utc) - timedelta(days=30)).isoformat()
end_date = datetime.now(timezone.utc).isoformat()

events = client.console.event_log(
card_template_id="0xd3adb00b5",
filters={
       "device": "mobile",
       "start_date": start_date,
       "end_date": end_date,
       "event_type": "install"
}
)

for event in events:
print(f"Event: {event.type} at {event.timestamp} by {event.user_id}")
```

```go
package main

import (
    "context"
    "fmt"
    "os"
    "time"
    "github.com/Access-Grid/accessgrid-go"
)

func main() {
    accountID := os.Getenv("ACCOUNT_ID")
    secretKey := os.Getenv("SECRET_KEY")

client, err := accessgrid.NewClient(accountID, secretKey)
    if err != nil {
        fmt.Printf("Error creating client: %v\n", err)
        return
    }

startDate := time.Now().AddDate(0, 0, -30).UTC()
    endDate := time.Now().UTC()
    filters := accessgrid.EventLogFilters{
        Device:    "mobile",
        StartDate: &startDate,
        EndDate:   &endDate,
        EventType: "install",
    }

ctx := context.Background()
    events, err := client.Console.EventLog(ctx, "0xd3adb00b5", filters)
    if err != nil {
        fmt.Printf("Error fetching event log: %v\n", err)
        return
    }

for _, event := range events {
        fmt.Printf("Event: %s at %s by %s\n", event.Type, event.Timestamp, event.UserID)
    }
}
```

```csharp
using AccessGrid;
using System;

public async Task GetEventLogAsync()
{
var accountId = Environment.GetEnvironmentVariable("ACCOUNT_ID");
var secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");

var client = new AccessGridClient(accountId, secretKey);

var events = await client.Console.EventLogAsync(
       "0xd3adb00b5",
       new EventLogFilters
       {
           Device = "mobile",
           StartDate = DateTime.UtcNow.AddDays(-30),
           EndDate = DateTime.UtcNow,
           EventType = "install"
       });

foreach (var evt in events)
{
       Console.WriteLine($"Event: {evt.Type} at {evt.Timestamp} by {evt.UserId}");
}
}
```

```java
import com.organization.accessgrid.AccessGridClient;
import com.organization.accessgrid.model.Event;
import com.organization.accessgrid.model.EventLogFilters;
import java.time.ZonedDateTime;
import java.util.List;

public class ConsoleService {
private final AccessGridClient client;

public ConsoleService() {
       String accountId = System.getenv("ACCOUNT_ID");
       String secretKey = System.getenv("SECRET_KEY");
       this.client = new AccessGridClient(accountId, secretKey);
}

public void getEventLog() throws AccessGridException {
       EventLogFilters filters = EventLogFilters.builder()
           .device("mobile")
           .startDate(ZonedDateTime.now().minusDays(30))
           .endDate(ZonedDateTime.now())
           .eventType("install")
           .build();

List<Event> events = client.console().eventLog("0xd3adb00b5", filters);

for (Event event : events) {
           System.out.printf("Event: %s at %s by %s\n",
               event.getType(),
               event.getTimestamp(),
               event.getUserId());
       }
}
}
```

```php
<?php

require 'vendor/autoload.php';

use AccessGridClient;

$accountId = $_ENV['ACCOUNT_ID'];
$secretKey = $_ENV['SECRET_KEY'];

$client = new Client($accountId, $secretKey);

$events = $client->console->eventLog([
'card_template_id' => '0xd3adb00b5',
'filters' => [
       'device' => 'mobile',
       'start_date' => (new DateTime('30 days ago'))->format('c'),
       'end_date' => (new DateTime('now'))->format('c'),
       'event_type' => 'install'
]
]);

foreach ($events as $event) {
echo "Event: {$event->type} at {$event->timestamp} by {$event->user_id}\n";
}
?>
```

```elixir
{:ok, client} = AccessGrid.new(
System.get_env("ACCOUNT_ID"),
System.get_env("SECRET_KEY")
)

{:ok, events} = AccessGrid.Console.event_log(client,
card_template_id: "0xd3adb00b5",
filters: %{
    device: "mobile",
    start_date: DateTime.utc_now() |> DateTime.add(-30, :day) |> DateTime.to_iso8601(),
    end_date: DateTime.utc_now() |> DateTime.to_iso8601(),
    event_type: "install"
}
)

Enum.each(events, fn event ->
IO.puts("Event: #{event.type} at #{event.timestamp} by #{event.user_id}")
done
)
```

### Response

```json
{
"logs": [
    {
      "id": "evt_91f2a7c3",
      "event": "install",
      "created_at": "2025-11-30T10:14:22Z",
      "ip_address": "192.168.1.24",
      "user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X)",
      "metadata": {
        "device": "mobile",
        "platform": "apple",
        "card_id": "key_a91c7e23",
        "template_id": "0xd3adb00b5"
      }
    },
    {
      "id": "evt_c83d19aa",
      "event": "install",
      "created_at": "2025-12-05T16:48:09Z",
      "ip_address": "10.0.0.88",
      "user_agent": "Mozilla/5.0 (Linux; Android 14; Pixel 8)",
      "metadata": {
        "device": "mobile",
        "platform": "android",
        "card_id": "key_b81d77ef",
        "template_id": "0xd3adb00b5"
      }
    }
],
"pagination": {
    "current_page": 1,
    "per_page": 20,
    "total_pages": 1,
    "total_count": 2
}
}
```