Przejdź do treści
Biblioteka skilli
Marketing i treści · Integracja z narzędziem

resend

/resend

Integruje Resend API z zarządzanym uwierzytelnianiem: wysyła e-maile transakcyjne, zarządza domenami, kontaktami, szablonami i broadcastami.

Licencja
MIT
Ostatnia zmiana repozytorium
20.07.2026

Ocena i bezpieczeństwo

86/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść26 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
39
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.07.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Integruje Resend API z zarządzanym uwierzytelnianiem: wysyła e-maile transakcyjne, zarządza domenami, kontaktami, szablonami i broadcastami.

Oryginalny opis (EN)

Resend API integration with managed authentication. Send transactional emails, manage domains, contacts, templates, and broadcasts. Use this skill when users want to send emails, manage email templates, create contact lists, or set up email broadcasts. For other third party apps, use the api-gateway skill (https://clawhub.ai/byungkyu/api-gateway).

Jak działa

  1. Quick Start
  2. Base URL
  3. Authentication
  4. Connection Management
  5. API Reference
  6. Code Examples
  7. Notes
  8. Error Handling
  9. Resources
Sekcje z nagłówków SKILL.md, w oryginale · 937 linii, 1 846 słów
Podgląd SKILL.md
---
name: resend
description: |
  Resend API integration with managed authentication. Send transactional emails, manage domains, contacts, templates, and broadcasts.
  Use this skill when users want to send emails, manage email templates, create contact lists, or set up email broadcasts.
  For other third party apps, use the api-gateway skill (https://clawhub.ai/byungkyu/api-gateway).
compatibility: Requires network access and valid Maton API key
metadata:
  author: maton
  version: "1.0"
  clawdbot:
    emoji: 🧠
    homepage: "https://maton.ai"
    requires:
      env:
        - MATON_API_KEY
---

# Resend

Access the Resend API with managed authentication. Send transactional emails, manage domains, contacts, templates, broadcasts, and webhooks.

## Quick Start

```bash
# List sent emails
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/emails')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

## Base URL

```
https://gateway.maton.ai/resend/{endpoint}
```

The gateway proxies requests to `api.resend.com` and automatically injects your API key.

## Authentication

All requests require the Maton API key in the Authorization header:

```
Authorization: Bearer $MATON_API_KEY
```

**Environment Variable:** Set your API key as `MATON_API_KEY`:

```bash
export MATON_API_KEY="YOUR_API_KEY"
```

### Getting Your API Key

1. Sign in or create an account at [maton.ai](https://maton.ai)
2. Go to [maton.ai/settings](https://maton.ai/settings)
3. Copy your API key

## Connection Management

Manage your Resend connections at `https://ctrl.maton.ai`.

### List Connections

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections?app=resend&status=ACTIVE')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

### Create Connection

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({'app': 'resend'}).encode()
req = urllib.request.Request('https://ctrl.maton.ai/connections', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

### Get Connection

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections/{connection_id}')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "connection": {
    "connection_id": "528c8f70-23f4-46d5-bd9f-01d0d043e573",
    "status": "ACTIVE",
    "creation_time": "2026-03-13T00:19:36.809599Z",
    "last_updated_time": "2026-03-13T09:59:08.443568Z",
    "url": "https://connect.maton.ai/?session_token=...",
    "app": "resend",
    "metadata": {},
    "method": "API_KEY"
  }
}
```

### Delete Connection

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections/{connection_id}', method='DELETE')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

### Specifying Connection

If you have multiple Resend connections, specify which one to use with the `Maton-Connection` header:

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/emails')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Maton-Connection', '528c8f70-23f4-46d5-bd9f-01d0d043e573')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

If omitted, the gateway uses the default (oldest) active connection.

## API Reference

### Emails

Send and manage transactional emails.

#### Send Email

```bash
POST /resend/emails
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'from': 'you@yourdomain.com',
    'to': ['recipient@example.com'],
    'subject': 'Hello from Resend',
    'html': '<p>Welcome to our service!</p>'
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/emails', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Request Body:**
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `from` | string | Yes | Sender email (must be from verified domain) |
| `to` | string[] | Yes | Recipient email addresses |
| `subject` | string | Yes | Email subject |
| `html` | string | No | HTML content |
| `text` | string | No | Plain text content |
| `cc` | string[] | No | CC recipients |
| `bcc` | string[] | No | BCC recipients |
| `reply_to` | string[] | No | Reply-to addresses |
| `attachments` | object[] | No | File attachments |
| `tags` | object[] | No | Email tags for tracking |
| `scheduled_at` | string | No | ISO 8601 datetime for scheduled send |

**Response:**
```json
{
  "id": "a52ac168-338f-4fbc-9354-e6049b193d99"
}
```

#### Send Batch Emails

```bash
POST /resend/emails/batch
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps([
    {'from': 'you@yourdomain.com', 'to': ['a@example.com'], 'subject': 'Email 1', 'text': 'Content 1'},
    {'from': 'you@yourdomain.com', 'to': ['b@example.com'], 'subject': 'Email 2', 'text': 'Content 2'}
]).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/emails/batch', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### List Emails

```bash
GET /resend/emails
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/emails')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "data": [
    {
      "id": "a52ac168-338f-4fbc-9354-e6049b193d99",
      "from": "you@yourdomain.com",
      "to": ["recipient@example.com"],
      "subject": "Hello from Resend",
      "created_at": "2026-03-13T10:00:00.000Z"
    }
  ]
}
```

#### Get Email

```bash
GET /resend/emails/{email_id}
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/emails/{email_id}')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Update Email

```bash
PATCH /resend/emails/{email_id}
```

#### Cancel Scheduled Email

```bash
DELETE /resend/emails/{email_id}
```

### Domains

Manage sending domains.

#### List Domains

```bash
GET /resend/domains
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/domains')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "data": [
    {
      "id": "5eb93a2e-e849-40a1-81b7-ed0fb574ddd8",
      "name": "yourdomain.com",
      "status": "verified",
      "created_at": "2026-03-13T10:00:00.000Z"
    }
  ]
}
```

#### Create Domain

```bash
POST /resend/domains
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({'name': 'yourdomain.com'}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/domains', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "id": "5eb93a2e-e849-40a1-81b7-ed0fb574ddd8",
  "name": "yourdomain.com",
  "status": "pending",
  "records": [
    {"type": "MX", "name": "...", "value": "..."},
    {"type": "TXT", "name": "...", "value": "..."}
  ]
}
```

#### Get Domain

```bash
GET /resend/domains/{domain_id}
```

#### Update Domain

```bash
PATCH /resend/domains/{domain_id}
```

#### Delete Domain

```bash
DELETE /resend/domains/{domain_id}
```

#### Verify Domain

```bash
POST /resend/domains/{domain_id}/verify
```

### Contacts

Manage contact lists.

#### List Contacts

```bash
GET /resend/contacts
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/contacts')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create Contact

```bash
POST /resend/contacts
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'email': 'contact@example.com',
    'first_name': 'John',
    'last_name': 'Doe'
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/contacts', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "id": "3cdc4bbb-0c79-46e5-be2a-48a89c29203d"
}
```

#### Get Contact

```bash
GET /resend/contacts/{contact_id}
```

#### Update Contact

```bash
PATCH /resend/contacts/{contact_id}
```

#### Delete Contact

```bash
DELETE /resend/contacts/{contact_id}
```

### Templates

Manage email templates.

#### List Templates

```bash
GET /resend/templates
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/templates')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create Template

```bash
POST /resend/templates
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'name': 'Welcome Email',
    'subject': 'Welcome to our service!',
    'html': '<h1>Welcome!</h1><p>Thanks for signing up.</p>'
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/templates', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Response:**
```json
{
  "id": "9b84737c-8a80-448a-aca1-c6e1fddd0f23"
}
```

#### Get Template

```bash
GET /resend/templates/{template_id}
```

#### Update Template

```bash
PATCH /resend/templates/{template_id}
```

#### Delete Template

```bash
DELETE /resend/templates/{template_id}
```

#### Publish Template

```bash
POST /resend/templates/{template_id}/publish
```

#### Duplicate Template

```bash
POST /resend/templates/{template_id}/duplicate
```

### Segments

Create audience segments for targeting.

#### List Segments

```bash
GET /resend/segments
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/segments')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create Segment

```bash
POST /resend/segments
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'name': 'Active Users',
    'filter': {
        'and': [
            {'field': 'email', 'operator': 'contains', 'value': '@'}
        ]
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/segments', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Get Segment

```bash
GET /resend/segments/{segment_id}
```

#### Delete Segment

```bash
DELETE /resend/segments/{segment_id}
```

### Broadcasts

Send emails to segments.

#### List Broadcasts

```bash
GET /resend/broadcasts
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/broadcasts')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create Broadcast

```bash
POST /resend/broadcasts
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'name': 'Weekly Newsletter',
    'from': 'newsletter@yourdomain.com',
    'subject': 'This Week\'s Update',
    'html': '<h1>Weekly Update</h1><p>Here\'s what happened...</p>',
    'segment_id': 'segment-uuid'
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/broadcasts', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Get Broadcast

```bash
GET /resend/broadcasts/{broadcast_id}
```

#### Update Broadcast

```bash
PATCH /resend/broadcasts/{broadcast_id}
```

#### Delete Broadcast

```bash
DELETE /resend/broadcasts/{broadcast_id}
```

#### Send Broadcast

```bash
POST /resend/broadcasts/{broadcast_id}/send
```

### Webhooks

Configure event notifications.

#### List Webhooks

```bash
GET /resend/webhooks
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/webhooks')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create Webhook

```bash
POST /resend/webhooks
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'endpoint': 'https://yoursite.com/webhook',
    'events': ['email.delivered', 'email.bounced', 'email.opened']
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/webhooks', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

**Webhook Events:**
- `email.sent` - Email was sent
- `email.delivered` - Email was delivered
- `email.opened` - Email was opened
- `email.clicked` - Link in email was clicked
- `email.bounced` - Email bounced
- `email.complained` - Recipient marked as spam

#### Get Webhook

```bash
GET /resend/webhooks/{webhook_id}
```

#### Update Webhook

```bash
PATCH /resend/webhooks/{webhook_id}
```

#### Delete Webhook

```bash
DELETE /resend/webhooks/{webhook_id}
```

### API Keys

Manage API keys.

#### List API Keys

```bash
GET /resend/api-keys
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/resend/api-keys')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

#### Create API Key

```bash
POST /resend/api-keys
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({'name': 'Production Key'}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/api-keys', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

> **Note:** The actual API key value is only returned once on creation.

#### Delete API Key

```bash
DELETE /resend/api-keys/{api_key_id}
```

### Topics

Manage subscription topics.

#### List Topics

```bash
GET /resend/topics
```

#### Create Topic

```bash
POST /resend/topics
```

**Example:**

```bash
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    'name': 'Newsletter',
    'default_subscription': 'subscribed'
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/resend/topics', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

> **Note:** `default_subscription` is required. Values: `subscribed` or `unsubscribed`.

#### Get Topic

```bash
GET /resend/topics/{topic_id}
```

#### Update Topic

```bash
PATCH /resend/topics/{topic_id}
```

#### Delete Topic

```bash
DELETE /resend/topics/{topic_id}
```

### Contact Properties

Manage custom contact properties.

#### List Contact Properties

```bash
GET /resend/contact-properties
```

#### Create Contact Property

```bash
POST /resend/contact-properties
```

#### Get Contact Property

```bash
GET /resend/contact-properties/{property_id}
```

#### Update Contact Property

```bash
PATCH /resend/contact-properties/{property_id}
```

#### Delete Contact Property

```bash
DELETE /resend/contact-properties/{property_id}
```

## Code Examples

### JavaScript

```javascript
// Send an email
const response = await fetch('https://gateway.maton.ai/resend/emails', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.MATON_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    from: 'you@yourdomain.com',
    to: ['recipient@example.com'],
    subject: 'Hello!',
    html: '<p>Welcome!</p>'
  })
});
const data = await response.json();
console.log(data.id);
```

### Python

```python
import os
import requests

response = requests.post(
    'https://gateway.maton.ai/resend/emails',
    headers={
        'Authorization': f'Bearer {os.environ["MATON_API_KEY"]}',
        'Content-Type': 'application/json'
    },
    json={
        'from': 'you@yourdomain.com',
        'to': ['recipient@example.com'],
        'subject': 'Hello!',
        'html': '<p>Welcome!</p>'
    }
)
email = response.json()
print(f"Email sent: {email['id']}")
```

## Notes

- Sending emails requires a verified domain
- Rate limit: 2 requests per second
- Batch emails accept up to 100 emails per request
- Scheduled emails can be set up to 7 days in advance
- Attachments support base64 encoded content or URLs
- The `from` address must use a verified domain
- IMPORTANT: When piping curl output to `jq` or other commands, environment variables like `$MATON_API_KEY` may not expand correctly in some shell environments

## Error Handling

| Status | Meaning |
|--------|---------|
| 400 | Bad request or missing Resend connection |
| 401 | Invalid or missing Maton API key |
| 403 | Domain not verified or permission denied |
| 404 | Resource not found |
| 422 | Validation error (missing required fields) |
| 429 | Rate limited (2 req/sec) |
| 4xx/5xx | Passthrough error from Resend API |

### Troubleshooting: API Key Issues

1. Check that the `MATON_API_KEY` environment variable is set:

```bash
echo $MATON_API_KEY
```

2. Verify the API key is valid by listing connections:

```bash
python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF
```

### Troubleshooting: Domain Not Verified

To send emails, you must first add and verify a domain:

1. Create a domain: `POST /resend/domains`
2. Add the DNS records provided in the response
3. Verify the domain: `POST /resend/domains/{id}/verify`

## Resources

- [Resend API Documentation](https://resend.com/docs/api-reference/introduction)
- [Resend Dashboard](https://resend.com)
- [Maton Community](https://discord.com/invite/dBfFAcefs2)
- [Maton Support](mailto:support@maton.ai)
Pliki w paczce (3)
  • LICENSE.txt 1 KB
  • SKILL.md 20 KB
  • _meta.json 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · LeoYeAI/openclaw-master-skills86MIT
motormetrics/motormetrics100MIT
gosodax/sodax-sdks100MIT
masumi-network/sokosumi100MIT
TerminalSkills/skills100Apache-2.0
growupanand/ConvoForm100Apache-2.0
vercel-labs/emulate100Apache-2.0
tdimino/claude-code-minoan100MIT
resend/resend-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 75700f9f9550 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100resend-cli
    Obsługuje platformę Resend z terminala: wysyła maile, zarządza domenami, kontaktami, webhookami i szablonami React Email.
  • 91sendgrid
    Integruje się z API SendGrid przez zarządzany OAuth, aby wysyłać e-maile, zarządzać kontaktami, szablonami i listami wykluczeń oraz oglądać statystyki wysyłki.
  • 86brevo
    Integruje się z Brevo przez zarządzane OAuth: e-mail marketing, e-maile transakcyjne, SMS, kontakty i CRM, kampanie, listy i szablony.
  • 100resend-cli
    Obsługuje platformę Resend z terminala przez CLI: wysyłka e-maili, także szablonów React Email, domeny, kontakty, broadcasty, webhooki, klucze API, logi i automatyzacje.
  • 91mailchimp
    Integruje Mailchimp Marketing API z zarządzaniem odbiorcami, kampaniami, szablonami, automatyzacjami i raportami.
  • 100local-email-481af394
    Podpowiada, jak wysyłać e-maile transakcyjne przez Resend z szablonami React Email, weryfikacją domeny i konfiguracją.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.