Ad Attribution logo

Ad Attribution

Community
rshankras
ad-attribution

Privacy-preserving ad measurement with AdAttributionKit (SKAdNetwork's successor) — install and re-engagement attribution, conversion-value strategy under crowd anonymity, and end-to-end postback testing. Use when running paid acquisition beyond Apple Ads, measuring re-engagement campaigns, designing conversion values, or migrating from SKAdNetwork.

Overview

Publisherrshankras
Repositoryclaude-code-apple-skills
Skill namead-attribution
Stars
744
Forks
70
Bundled files
Instructions only
LicenseMIT
Links
Skill sourceRepository
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by rshankras on GitHub. Read the source before you install it.

Installation

Install the Ad Attribution AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/rshankras/claude-code-apple-skills.git /tmp/claude-code-apple-skills
mkdir -p .claude/skills
cp -r /tmp/claude-code-apple-skills/skills/app-store/ad-attribution .claude/skills/ad-attribution
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Ad Attribution in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Ad Attribution on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Ad Attribution is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Ad Attribution (AdAttributionKit)

You can't optimize paid traffic you can't measure. AdAttributionKit is Apple's privacy-preserving attribution framework — interoperable with SKAdNetwork, and the go-forward path (it also works in alternative marketplaces). This skill covers the advertised-app side: what an indie running paid campaigns must implement and how to design conversion signals that survive privacy thresholds.

Note the seam: Apple Ads attribution uses the AdServices framework, not AdAttributionKit — campaigns there are measured in the Apple Ads console (see app-store/apple-search-ads). This skill is for every other paid channel (ad networks, social, publishers).

When This Skill Activates

  • Running or planning paid user acquisition outside Apple Ads
  • "How do I know which campaign drove installs?" / measuring re-engagement ads
  • Designing or debugging conversion values / postbacks
  • Migrating from SKAdNetwork (fully interoperable — registered networks need no re-enrollment)

How it works (the 60-second model)

Ad network signs an ad (compact JWS impression) → publisher app shows it → user installs (or re-engages) → after a privacy-delayed measurement window, a postback with your conversion info goes to the ad network (and optionally to you). Attribution requires no user tracking; the price is coarser data, governed by crowd anonymity.

Conversion-value strategy (the part that's actually yours)

  • Two granularities: fine value 0–63 and coarse low/medium/high. Low crowd sizes downgrade fine → coarse and can trim the 4-digit campaign source-identifier to as few as its first 2 digits — so encode what matters most (campaign family, geo tier) in the first two digits, detail in the rest.
  • Map values to revenue-predictive early behavior (completed onboarding, trial start, first purchase), not vanity events. 64 slots go fast; reserve ranges (e.g. 0–15 activation, 16–47 monetization ladder, 48–63 reserved).
  • Update with updateConversionValue(_:) / PostbackUpdate; set lockPostback when the value is final to schedule transmission (still privacy-delayed, never instant).
  • Re-engagement postbacks are separate from install postbacks: update them independently via conversionTypes (.install / .reengagement); the first re-engagement update must land within 48 hours.
  • Multiple simultaneous re-engagement campaigns need conversion tags (iOS 18.4+): read the tag from the re-engagement URL's query items, store it, and pass it in PostbackUpdate — without a tag, updates hit only the most recent conversion.

Publisher-side mechanics (if your app also shows ads)

  • Click-through: UIEventAttributionView over the tappable ad + appImpression.handleTap() within 15 minutes of creating the impression.
  • View-through: beginView()/endView() on the same instance; ≥2 seconds on screen to count; one open view-through per network per advertised app.
  • SKOverlay / SKStoreProductViewController: attach the impression — they count view on present, click on tap.

Attribution windows & cooldowns (iOS 18.4+ configurability)

  • Defaults: 30 days click-through, 1 day view-through (install ads).
  • Override per ad network and interaction type in Info.plist (AdAttributionKitConfigurations → AttributionWindows); you can ignore "view" or "click" (not both) per network.
  • Set cooldowns (install-cooldown-hours, reengagement-cooldown-hours) so a re-engagement tap minutes after an install isn't double-attributed.
  • Country-level postback data (iOS 18.4): storefront country at install, gated behind an extra crowd-anonymity tier — a bonus signal when volume allows, never guaranteed.
  • Overlapping re-engagement conversions require opting in: EligibleForAdAttributionKitOverlappingConversions = YES in Info.plist.

Testing — never ship blind

  • Developer Mode → Settings → Developer → Ad Attribution Testing: removes time randomization, shortens all conversion windows, sends postbacks on demand — full end-to-end rehearsal in minutes instead of days.
  • Point development postbacks at a separate dev endpoint, never production: they're signed with a different key (kid), the network ID is always development.adattributionkit, and the advertised item ID may be 0 from Xcode.
  • ✅ Verify the postback pipeline before spending a dollar. ❌ Debugging attribution after a live campaign burns budget on unmeasurable installs.

Checklist

  • Conversion-value map documented (0–63 + coarse fallback + first-2-digit priority)
  • lockPostback fired once value is final; re-engagement first update < 48h
  • Conversion tags wired if >1 re-engagement campaign runs at once
  • Cooldowns configured; windows tuned per network where defaults don't fit
  • Dev-endpoint postback rehearsal done in Developer Mode
  • Campaign readout joined with growth/analytics-interpretation (source-type funnel) — attribution tells you which ad, App Analytics tells you what they did after

References

Frequently asked questions

What does the Ad Attribution AI skill do?

Privacy-preserving ad measurement with AdAttributionKit (SKAdNetwork's successor) — install and re-engagement attribution, conversion-value strategy under crowd anonymity, and end-to-end postback testing. Use when running paid acquisition beyond Apple Ads, measuring re-engagement campaigns, designing conversion values, or migrating from SKAdNetwork.

Why use Ad Attribution on TypingMind?

Because you install it once and use it with any model. Ad Attribution is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Ad Attribution in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/rshankras/claude-code-apple-skills/tree/main/skills/app-store/ad-attribution. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Ad Attribution?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Ad Attribution?

As many as you like. As long as a model supports skills, you can use Ad Attribution with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Ad Attribution AI skill free?

Yes. It is published on GitHub by rshankras under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

Related AI Skills

View all
obra logo

Test Driven Development

obra
CommunityPopular

Use when implementing any feature or bugfix, before writing implementation code

25.8K
288.1K
1 files
View
obra logo

Using Git Worktrees

obra
CommunityPopular

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

25.8K
288.1K
Instructions
View
obra logo

Using Superpowers

obra
CommunityPopular

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

25.8K
288.1K
5 files
View
obra logo

Verification Before Completion

obra
CommunityPopular

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence…

25.8K
288.1K
Instructions
View

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇