- Home
- Skills
- APIs & Backend
- Kafka Spring Production Reviewer: Lost & Duplicate Messages
More screenshots
Works with the AI Agents you already use
Kafka Spring Production Reviewer: Lost & Duplicate Messages
The listener hands work to a thread pool and returns, so the offset commits before the database write.
$12
Kafka Spring Production Reviewer: Lost & Duplicate Messages
Example session with this skill installed
We go live with this payments consumer next week. Spring Boot 3.3, Java 21, Kafka 3.7, PostgreSQL. Review it for production problems before we ship.
PaymentEventsListener.java
@Service
public class PaymentEventsListener {
private static final Logger log = LoggerFactory.getLogger(PaymentEventsListener.class);
private final PaymentRepository payments;
private final LedgerClient ledger;
private final KafkaTemplate<String, PaymentSettled> kafka;
private final ExecutorService workers = Executors.newVirtualThreadPerTaskExecutor();
public PaymentEventsListener(PaymentRepository payments, LedgerClient ledger,
KafkaTemplate<String, PaymentSettled> kafka) {
this.payments = payments;
this.ledger = ledger;
this.kafka = kafka;
}
@KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
public void onPayment(PaymentEvent event) {
workers.submit(() -> handle(event)); // virtual threads, so this scales
}
@Transactional
void handle(PaymentEvent event) {
try {
Payment payment = payments.save(Payment.from(event));
ledger.post(payment);
kafka.send("payments-settled", payment.getId().toString(), PaymentSettled.of(payment));
} catch (Exception e) {
log.error("payment {} failed", event.getPaymentId(), e);
}
}
}
LedgerClient.java
@Component
public class LedgerClient {
private final RestClient http;
private String accessToken;
private Instant expiresAt = Instant.EPOCH;
public LedgerClient(RestClient.Builder builder) {
this.http = builder.baseUrl("https://ledger.internal").build();
}
public void post(Payment payment) {
http.post().uri("/entries")
.header("Authorization", "Bearer " + currentToken())
.body(LedgerEntry.of(payment))
.retrieve()
.toBodilessEntity();
}
private synchronized String currentToken() {
if (Instant.now().isAfter(expiresAt)) {
TokenResponse t = http.post().uri("/oauth/token").retrieve().body(TokenResponse.class);
accessToken = t.value();
expiresAt = Instant.now().plusSeconds(t.expiresIn() - 30);
}
return accessToken;
}
}
application.yml
spring:
threads:
virtual:
enabled: true
kafka:
bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
consumer:
enable-auto-commit: true
auto-offset-reset: latest
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
properties:
spring.json.trusted.packages: "*"
producer:
acks: 1
value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
- Read your context and instructions
- Compiled the kafka spring production
1. Verdict
Don't ship this as written. The worst problem is that the Kafka offset for a payment is committed before the payment has been processed, and any exception is caught and only logged. So a normal deploy, a restart, or a brief ledger outage loses payments, and the only trace is a log line.
Versions reviewed against: Spring Boot 3.3, spring-kafka 3.2, kafka-clients 3.7, running on JDK 21 (the virtual-thread pinning in finding 6 depends on that).
2. Findings
1. [Critical] Offsets are committed before the payment is processed
Where: PaymentEventsListener.java, onPayment: workers.submit(() -> handle(event)); application.yml: enable-auto-commit: true
What happens: there are two independent causes, and each one is enough to lose payments.
onPaymenthands the record to a virtual thread and returns at once. The container treats the record as done.enable-auto-commit: truemakes the Kafka client commit offsets every 5 s duringpoll(), whether or not any work finished. This setting also overrides spring-kafka's own commit handling.
Step by step: the pod receives SIGTERM during a deploy. The worker tasks that are still queued or running are dropped, and their offsets are already committed. The new pod starts after those offsets, so those payments are never saved or posted to the ledger, and nobody is told.
The same hand-off causes three more problems:
- Exceptions in the task never reach a Kafka error handler.
- Two events for the same payment can run at the same time, so their order is not kept.
- There is no limit on concurrency. A backlog creates thousands of virtual threads competing for 10 Hikari connections, so
save()calls time out, and finding 2 then drops those payments too.
Fix: do the work on the listener thread and delete the executor. Remove enable-auto-commit, so spring-kafka commits after the listener returns. Virtual threads don't add parallelism here: throughput comes from the number of partitions and concurrency.
@KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
public void onPayment(PaymentEvent event) {
handler.handle(event); // separate bean, see finding 4; throws on failure
}
Verify: an integration test with Testcontainers Kafka. Publish 1,000 events, stop the container partway through, start it again, and assert 1,000 payment rows.
2. [Critical] Failures are swallowed and there is no dead-letter topic
Where: PaymentEventsListener.java, handle: catch (Exception e) { log.error(...) }; no CommonErrorHandler bean
What happens: the ledger returns a 503 for 30 s, or the database refuses a connection. Every payment in that window is logged and treated as succeeded, and none is retried. Even if the catch is removed, spring-kafka's default error handler tries 10 times with no pause and then only logs the record and skips it.
Fix: remove the catch. Add a DefaultErrorHandler with back-off and a DeadLetterPublishingRecoverer, and declare payments.DLT with at least as many partitions as payments (full code in section 5). Set up an alert on any traffic to the DLT.
Verify: stub the ledger to return 503 three times, then 200. Assert that the payment is posted once and nothing goes to the DLT. Then stub a 400 and assert the record lands on payments.DLT with the kafka_dlt-exception-* headers.
3. [High] Redelivered events save the payment twice and post to the ledger twice
Where: PaymentEventsListener.java, handle: payments.save(Payment.from(event)) and ledger.post(payment)
What happens: once findings 1 and 2 are fixed, delivery is at-least-once, so redeliveries become routine. They happen on a rebalance, on a retry after the ledger call has already succeeded, or after a crash before the commit. Nothing checks whether an event was already processed. The second delivery inserts another Payment (if Payment.from generates the ID) and posts a second ledger entry. That moves money twice, so this is a duplicate that counts as data loss.
Fix: two parts.
- Record a dedupe row in the same database transaction as the payment insert, keyed on a stable event ID:
INSERT ... ON CONFLICT DO NOTHING, then skip the event if no row was inserted. - Send the ledger an idempotency key derived from the event, such as
Idempotency-Key: payment-<eventId>. That covers the case where the ledger call succeeds but the database commit fails.
Code is in section 5.
Verify: publish the same event twice. Assert one payment row, one ledger call (WireMock), and one payments-settled record.
4. [High] @Transactional never applies, and the Kafka send is an unprotected second write
Where: PaymentEventsListener.java, handle: @Transactional void handle(...) and kafka.send("payments-settled", ...)
What happens
The transaction does nothing. handle is called from a lambda inside the same class (this.handle), on another thread, and it isn't public. Spring's transaction proxy only applies when the method is called through the bean from outside the class. So there is no transaction: save() commits on its own. If ledger.post then fails, a payment row exists with no ledger entry.
The Kafka send can be lost. kafka.send(...) returns a future that nobody checks. If the broker is unreachable past delivery.timeout.ms, or the pod dies before the send is flushed, the ledger has the entry but the payments-settled event is never published. A real transaction wouldn't fix this either, because the database commit and the Kafka send are two separate writes that can't be made atomic.
Fix: move handle into its own @Component with a public @Transactional method. Write the PaymentSettled event to an outbox table in that same transaction, and publish it with a relay that marks a row as sent only after the broker acknowledges it.
Verify: make the outbox insert or the commit fail after save(). Assert there is no payment row and nothing is published. Then kill the broker connection after the commit and assert the event is still published once the broker is back.
5. [High] One malformed record blocks its partition forever
Where: application.yml: value-deserializer: ...JsonDeserializer, spring.json.trusted.packages: "*"
What happens: a producer publishes one record that isn't valid JSON, or that has a __TypeId__ header naming a class this service doesn't have. JsonDeserializer throws inside poll(), before the listener or error handler ever sees the record. The container then fails on the same offset in a loop, and every later payment on that partition stops.
Separately, trusted.packages: "*" combined with type headers lets any producer on the topic choose which class Jackson creates. That is unsafe for a payments topic.
Fix: wrap both deserializers in ErrorHandlingDeserializer. Set a fixed target type, turn off type headers, and trust only your own package (YAML in section 5). The bad record then goes to the DLT and the partition keeps moving.
Verify: publish the raw bytes not-json to payments, then a valid event. Assert the first lands on payments.DLT and the second is processed.
6. [High] synchronized token refresh can stall every virtual thread in the app
Where: LedgerClient.java, currentToken: private synchronized String currentToken() with an HTTP call inside it
What happens: on JDK 21–23, a virtual thread blocks the OS thread underneath it (it is "pinned") while it does I/O inside a synchronized method. Virtual threads waiting to enter that method are pinned too. There is one such OS thread per CPU core by default.
When the token expires, which happens on every token lifetime, one thread makes the token call while pinned, and the threads queued behind it pin the rest. Every virtual thread in the JVM then waits: the Kafka listener containers (because spring.threads.virtual.enabled: true) and web requests alike. Combined with finding 7 (no timeouts), a slow token endpoint can freeze the whole service.
Fix: use a ReentrantLock instead of synchronized (section 5). If you run JDK 24 or later, this pinning no longer happens (JEP 491); tell me and I'll downgrade this finding.
Verify: run a load test with -Djdk.tracePinnedThreads=full or JFR's jdk.VirtualThreadPinned event, with the token expiry forced to a few seconds. Expect no pinning events from LedgerClient.
7. [High] The ledger client has no timeouts
Where: LedgerClient.java, constructor: builder.baseUrl(...).build() with no request factory settings
What happens: by default the client has no read timeout. Once processing runs on the listener thread (finding 1), a ledger call that hangs holds that thread. After max.poll.interval.ms (5 min) the consumer is removed from the group, its partitions move to another consumer, and the batch is processed again. Without finding 3's idempotency key, that is a second ledger post.
Fix: set a connect timeout of about 2 s and a read timeout of about 10 s (section 5). Keep the worst case for one poll's records well under 5 minutes, or lower max.poll.records.
Verify: a WireMock test with a 30 s fixed delay. Assert that the call fails within the timeout and the record goes through retry and then the DLT.
8. [High] auto-offset-reset: latest on a brand-new consumer group skips existing payments
Where: application.yml: auto-offset-reset: latest
What happens: ledger-sync is a new group, so it has no committed offsets on its first start. If producers start publishing to payments before this consumer's first deploy, or a rollout fails and is retried, the group starts at the end of the topic. Every payment already on it is never processed. The same happens if the group is idle for longer than the broker's offset retention (7 days by default).
Fix: set earliest. Be careful: if payments already holds history that must not go to the ledger, earliest replays all of it. In that case, set the group's starting point once, before go-live, with kafka-consumer-groups.sh --group ledger-sync --topic payments --reset-offsets --to-datetime <cutover> --execute. Then keep earliest as the safety net.
Verify: before go-live, run kafka-consumer-groups.sh --describe --group ledger-sync and confirm the committed offsets match the planned cutover.
9. [High] acks: 1 loses acknowledged payments-settled events when a broker fails
Where: application.yml: producer.acks: 1
What happens: with acks: 1, the partition leader acknowledges the send before any follower has copied it. If the leader broker crashes right then, a follower without the record becomes leader and the event is gone, though the producer saw it as sent. acks: 1 also turns off producer idempotence, so the producer's own retries can duplicate or reorder events.
Fix: remove the line (the default since kafka-clients 3.0 is all), or set acks: all. On the topic, use replication factor 3 with min.insync.replicas=2.
Verify: run kafka-configs.sh --describe --topic payments-settled to check min.insync.replicas. A chaos test that kills the leader during sends should find no gaps in the outbox IDs the consumer receives.
3. Checked and fine
Exactly-once / Kafka transactions: nothing in the code claims exactly-once, and no transactional producer is configured. The fixed path is at-least-once with idempotent processing, which is the right model here.
- Keys on
payments-settled: keyed by payment ID, which is stable, so events for one payment stay in order.
Shared mutable state: the listener holds no per-record fields. LedgerClient's token fields are only touched under the lock, so they stay safe after the ReentrantLock change.
- Calling
KafkaConsumerfrom other threads: not done.
Large records and tombstones: nothing visible suggests large payloads or a compacted topic. See questions 1 and 6.
4. Questions
- Does
PaymentEventhave its own event ID, or onlypaymentId? If one payment can produce several events (authorized, settled, refunded), the dedupe key must be the event ID, or later events are skipped as duplicates. (Finding 3)
Does the ledger API accept an idempotency key? If it doesn't, a crash between the ledger post and the database commit can still double-post, and you'll need a reconciliation job. (Finding 3)
3. Does payments already contain events that must not reach the ledger? This decides between earliest and a one-off offset reset at cutover. (Finding 8)
4. How many partitions does payments have, and what are the replication factor and min.insync.replicas on both topics? concurrency = "6" above the partition count leaves consumers idle, and payments.DLT needs at least that many partitions. (Findings 2, 9)
5. Which JDK runs in production, 21 or 24+? (Finding 6)
6. Do consumers of payments-settled depend on the __TypeId__ header that JsonSerializer adds? The outbox relay below sends plain JSON strings. If they need the header, the relay should add it. (Finding 4)
7.
Does /oauth/token need client credentials? The request sends no body or auth, so it likely gets a 401 in production. (Not a Kafka issue, but the service won't work without it.)
5. Fixed version
PaymentEventsListener.java:
@Service
public class PaymentEventsListener {
private final PaymentEventHandler handler;
public PaymentEventsListener(PaymentEventHandler handler) {
this.handler = handler;
}
@KafkaListener(topics = "payments", groupId = "ledger-sync", concurrency = "6")
public void onPayment(PaymentEvent event) {
handler.handle(event); // same thread; exceptions go to the error handler
}
}
PaymentEventHandler.java (new bean, so the @Transactional proxy applies):
@Component
public class PaymentEventHandler {
private final JdbcTemplate jdbc;
private final PaymentRepository payments;
private final OutboxRepository outbox;
private final LedgerClient ledger;
private final ObjectMapper json;
// constructor omitted
@Transactional
public void handle(PaymentEvent event) {
int inserted = jdbc.update("""
INSERT INTO processed_event (consumer_group, event_id, processed_at)
VALUES ('ledger-sync', ?, now()) ON CONFLICT DO NOTHING""", event.getEventId());
if (inserted == 0) {
return; // already processed
}
Payment payment = payments.save(Payment.from(event));
ledger.post(payment, "payment-" + event.getEventId()); // ledger dedupes on the key
outbox.save(OutboxEvent.of(UUID.randomUUID(), payment.getId().toString(),
"PaymentSettled", json.writeValueAsString(PaymentSettled.of(payment))));
} // any exception rolls everything back and the record is retried
}
The ledger call runs inside the transaction, so it holds a database connection while it waits. With concurrency 6 against Hikari's default pool of 10 that's fine, but keep concurrency below the pool size. writeValueAsString throws a checked exception: wrap it, or declare throws.
OutboxRelay.java:
@Component
class OutboxRelay {
private final JdbcTemplate jdbc;
private final KafkaTemplate<String, String> stringTemplate; // StringSerializer, acks=all
@Scheduled(fixedDelay = 500)
@Transactional
public void publish() throws Exception {
var rows = jdbc.query("""
SELECT id, aggregate_id, payload FROM outbox_event
WHERE sent_at IS NULL ORDER BY created_at
LIMIT 100 FOR UPDATE SKIP LOCKED""",
(rs, i) -> new OutboxRow(rs.getObject(1, UUID.class), rs.getString(2), rs.getString(3)));
for (var row : rows) {
var rec = new ProducerRecord<>("payments-settled", row.aggregateId(), row.payload());
rec.headers().add("event-id", row.id().toString().getBytes(StandardCharsets.UTF_8));
stringTemplate.send(rec).get(10, TimeUnit.SECONDS); // broker ack first
jdbc.update("UPDATE outbox_event SET sent_at = now() WHERE id = ?", row.id());
}
}
}
The relay can publish an event twice (for example, a crash after the send and before the update), so consumers of payments-settled should dedupe on the event-id header. If strict order per payment matters across several replicas, run only one relay (for example with ShedLock).
LedgerClient.java:
@Component
public class LedgerClient {
private final RestClient http;
private final ReentrantLock tokenLock = new ReentrantLock();
private String accessToken;
private Instant expiresAt = Instant.EPOCH;
public LedgerClient(RestClient.Builder builder) {
var factory = new JdkClientHttpRequestFactory(
HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).build());
factory.setReadTimeout(Duration.ofSeconds(10));
this.http = builder.baseUrl("https://ledger.internal").requestFactory(factory).build();
}
public void post(Payment payment, String idempotencyKey) {
http.post().uri("/entries")
.header("Authorization", "Bearer " + currentToken())
.header("Idempotency-Key", idempotencyKey)
.body(LedgerEntry.of(payment))
.retrieve()
.toBodilessEntity();
}
private String currentToken() {
tokenLock.lock();
try {
if (Instant.now().isAfter(expiresAt)) {
TokenResponse t = http.post().uri("/oauth/token") // add client credentials, see question 7
.retrieve().body(TokenResponse.class);
accessToken = t.value();
expiresAt = Instant.now().plusSeconds(Math.max(0, t.expiresIn() - 30));
}
return accessToken;
} finally {
tokenLock.unlock();
}
}
}
KafkaErrorHandling.java:
@Configuration
class KafkaErrorHandling {
@Bean
DefaultErrorHandler errorHandler(KafkaTemplate<Object, Object> jsonTemplate,
ProducerFactory<Object, Object> pf) {
// Records that failed to deserialize carry their raw bytes, so they need a byte[] template
var bytesTemplate = new KafkaTemplate<>(new DefaultKafkaProducerFactory<>(
pf.getConfigurationProperties(), new StringSerializer(), new ByteArraySerializer()));
Map<Class<?>, KafkaOperations<?, ?>> templates = new LinkedHashMap<>();
templates.put(byte[].class, bytesTemplate);
templates.put(Object.class, jsonTemplate);
var recoverer = new DeadLetterPublishingRecoverer(templates,
(rec, ex) -> new TopicPartition(rec.topic() + ".DLT", rec.partition()));
var backOff = new ExponentialBackOffWithMaxRetries(5);
backOff.setInitialInterval(500);
backOff.setMultiplier(2.0);
backOff.setMaxInterval(10_000);
var handler = new DefaultErrorHandler(recoverer, backOff);
handler.addNotRetryableExceptions(HttpClientErrorException.class); // 4xx: send straight to the DLT
return handler;
}
@Bean
NewTopic paymentsDlt() {
return TopicBuilder.name("payments.DLT").partitions(6).replicas(3).build(); // at least the partition count of "payments"
}
}
application.yml:
spring:
threads:
virtual:
enabled: true
kafka:
bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
consumer:
auto-offset-reset: earliest # set the cutover offsets first, see finding 8
key-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer
value-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer
properties:
spring.deserializer.key.delegate.class: org.apache.kafka.common.serialization.StringDeserializer
spring.deserializer.value.delegate.class: org.springframework.kafka.support.serializer.JsonDeserializer
spring.json.value.default.type: com.example.payments.PaymentEvent
spring.json.use.type.headers: false
spring.json.trusted.packages: com.example.payments
producer:
acks: all
value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
enable-auto-commit is removed on purpose.
Schema
CREATE TABLE processed_event (
consumer_group VARCHAR(100) NOT NULL,
event_id VARCHAR(100) NOT NULL,
processed_at TIMESTAMP NOT NULL,
PRIMARY KEY (consumer_group, event_id)
);
CREATE TABLE outbox_event (
id UUID PRIMARY KEY, aggregate_id VARCHAR(100) NOT NULL, event_type VARCHAR(100) NOT NULL,
payload TEXT NOT NULL, created_at TIMESTAMP NOT NULL DEFAULT now(), sent_at TIMESTAMP
);
CREATE INDEX outbox_unsent ON outbox_event (created_at) WHERE sent_at IS NULL;
Before go-live, run the four tests together: the crash test from finding 1, the duplicate-delivery test from finding 3, the malformed-record test from finding 5, and the slow-ledger test from finding 7. Between them they cover every Critical and High finding except the cutover offsets (finding 8), the acks setting (finding 9) and the token-lock pinning (finding 6), which you check with the commands and load test listed in those findings.
Connects securely to your tools. The creator never sees your data.
About this skill
Kafka code that passes every unit test can still lose payments on the next
deploy. The listener hands work to a thread pool and returns, so the offset
commits before the database write. A catch (Exception e) logs and moves on,
so a failed record is marked done. A bad JSON message blocks its partition
forever. Generic code review rarely catches these, because the bug is in how
Kafka, Spring and the database interact, not in any single line.
Kafka Spring Production Reviewer makes your agent review that interaction. For every listener and producer it traces the message from poll to commit, lists each side effect, and asks what happens when each step fails. Then it walks a ten-area checklist:
- Offsets and commits (auto commit, early commits, manual acks, off-by-one)
- Idempotent consumers (dedupe keys, races, external side effects)
- Retries and error handling (swallowed exceptions, Spring defaults, batches)
- Dead-letter topics (naming, partitions, alerting, replay)
- Poison messages and deserialization
- Exactly-once claims and Kafka transactions
- Transactional outbox and dual writes (including
@Transactionalthat does nothing) - Producer durability and unchecked send results
- Rebalances and consumer liveness
- Concurrency, ordering and virtual threads on Java 21
Every finding comes with a severity (Critical, High, Medium, Low), the exact
file and line, a step-by-step failure scenario, a minimal fix in your own
names and types, and a test that proves the fix. A finding without a concrete
failure scenario is not reported, so you get a short list you can act on, not
a wall of maybes. It also says which areas it checked and found fine, and
which facts it needs from you (partition counts, topic min.insync.replicas).
The package has the SKILL.md, three reference files (the checklist, Spring Boot fix patterns for outbox, DLT, poison pills and idempotent consumers, and a table of Kafka and Spring defaults by version), and a read-only Python scanner that lists hotspots in a large repo so the agent knows where to look.
Requires: an agent that loads SKILL.md skills, such as Claude Code. Java or Kotlin code using Kafka (Spring Boot and spring-kafka get the most specific advice). Python 3 only for the optional scanner. No API keys, no network.
Known limitations
- It reviews code and config it can see. Broker and topic settings
(partitions, replication,
min.insync.replicas) are asked about, not guessed. - Static review only: it does not run your app, a broker or your tests.
- Kafka Streams, reactive Kafka and non-Spring clients get the general checks, not framework-specific fixes.
- The scanner is a pattern matcher. It finds leads quickly; the full review still reads the code.
FAQ
Which versions does it know? Java 21+, Spring Boot 3.x, spring-kafka 3.x and kafka-clients 3.x to 4.x. It reads your build file and states the versions it reviewed against, because defaults changed between versions.
Will it rewrite my code? It proposes fixes and, for small classes, a full corrected version. It changes files only if you ask it to.
Does the scanner send my code anywhere? No. It reads the paths you pass, prints results, writes nothing and makes no network calls.
Is it useful without Spring? Yes for commits, idempotency, outbox, rebalances and producer durability; Spring-specific fixes are skipped.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.
It reviews code and config it can see. Broker and topic settings (partitions, replication, min.insync.replicas) are asked about, not guessed. Static review only: it does not run your app, a broker or your tests. Kafka Streams, reactive Kafka and non-Spring clients get the general checks, not framework-specific fixes. The scanner is a pattern matcher. It finds leads quickly; the full review still reads the code.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 10 days ago