diff --git a/android-lib/build.gradle b/android-lib/build.gradle
index 1f0511b..6eac8e0 100644
--- a/android-lib/build.gradle
+++ b/android-lib/build.gradle
@@ -8,6 +8,7 @@
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
         classpath 'com.android.tools.build:gradle:1.2.3'
         classpath 'com.jakewharton.sdkmanager:gradle-plugin:0.12.0'
+        classpath 'io.v:gradle-plugin:1.4'
     }
 }
 
@@ -16,6 +17,7 @@
 apply plugin: 'maven-publish'
 apply plugin: 'wrapper'
 apply plugin: 'com.jfrog.bintray'
+apply plugin: 'io.v.vdl'
 
 // You should change this after releasing a new version of the library. See the
 // list of published versions at https://repo1.maven.org/maven2/io/v/vanadium-android.
@@ -56,6 +58,10 @@
     }
 }
 
+vdl {
+    inputPaths += 'src/main/java'
+}
+
 public static isDarwin() {
     return getOS().contains("os x")
 }
diff --git a/android-lib/src/main/AndroidManifest.xml b/android-lib/src/main/AndroidManifest.xml
index 800e17f..b9b89a3 100644
--- a/android-lib/src/main/AndroidManifest.xml
+++ b/android-lib/src/main/AndroidManifest.xml
@@ -14,10 +14,21 @@
     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
     <uses-permission android:name="android.permission.BLUETOOTH" />
 
+    <uses-permission android:name="android.permission.NFC" />
+
     <application>
-        <activity
-            android:name="io.v.android.impl.google.services.blessing.BlessingActivity"
+        <activity android:name="io.v.android.impl.google.services.blessing.BlessingActivity"
             android:excludeFromRecents="true"/>
+        <activity android:name="io.v.android.impl.google.services.beam.BeamActivity"
+            android:excludeFromRecents="true">
+            <intent-filter>
+                <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:scheme="vnd.android.nfc"
+                    android:host="ext"
+                    android:pathPrefix="/io.v.android.vbeam:vbs"/>
+            </intent-filter>
+        </activity>
     </application>
 
 </manifest>
diff --git a/android-lib/src/main/java/io/v/android/impl/google/services/beam/BeamActivity.java b/android-lib/src/main/java/io/v/android/impl/google/services/beam/BeamActivity.java
new file mode 100644
index 0000000..e1950ca
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/impl/google/services/beam/BeamActivity.java
@@ -0,0 +1,108 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.impl.google.services.beam;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.nfc.NdefMessage;
+import android.nfc.NfcAdapter;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.support.v4.app.ActivityCompat;
+import android.util.Log;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+import org.joda.time.Duration;
+
+import io.v.android.v23.V;
+import io.v.android.v23.VBeam;
+import io.v.v23.OptionDefs;
+import io.v.v23.Options;
+import io.v.v23.context.VContext;
+import io.v.v23.security.VSecurity;
+
+/**
+ * Handles the NDEF discovered intent on the receiver phone.
+ * It contacts the VBeam server on the sending phone, then retrieves and starts the shared intent.
+ */
+public class BeamActivity extends Activity {
+
+    private static final String TAG = "BeamActivity";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        NdefMessage msgs[] = null;
+        Intent intent = getIntent();
+
+        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(intent.getAction())) {
+            Parcelable[] rawMsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
+            if (rawMsgs != null) {
+                msgs = new NdefMessage[rawMsgs.length];
+                for (int i = 0; i < rawMsgs.length; i++) {
+                    msgs[i] = (NdefMessage) rawMsgs[i];
+                }
+            }
+        }
+        if (msgs == null) {
+            Log.d(TAG, "No ndef messages");
+            finish();
+            return;
+        }
+        VBeamManager.Data data = null;
+        for (NdefMessage m : msgs) {
+            data = VBeamManager.decodeMessage(m);
+            if (data != null)
+                break;
+        }
+        if (data == null) {
+            Log.w(TAG, "Unable to deserialize data");
+            finish();
+            return;
+        }
+        Log.d(TAG, "connecting to " + data.name);
+        VContext ctx = V.init(this).withTimeout(Duration.standardSeconds(2));
+        Options opts = new Options();
+
+        opts.set(OptionDefs.SERVER_AUTHORIZER, VSecurity.newPublicKeyAuthorizer(data.key));
+        IntentBeamerClient client = IntentBeamerClientFactory.getIntentBeamerClient(data.name);
+        ListenableFuture<IntentBeamerClient.GetIntentOut> out =
+                client.getIntent(ctx, data.secret, opts);
+        Futures.addCallback(out, new FutureCallback<IntentBeamerClient.GetIntentOut>() {
+            @Override
+            public void onSuccess(IntentBeamerClient.GetIntentOut result) {
+                try {
+                    Log.d(TAG, "got intent " + result.intentUri);
+                    int flags = 0;
+                    if (result.intentUri.startsWith("intent:")) {
+                        flags = Intent.URI_INTENT_SCHEME;
+                    } else {
+                        flags = Intent.URI_ANDROID_APP_SCHEME;
+                    }
+                    Intent resultIntent = Intent.parseUri(result.intentUri, flags);
+                    resultIntent.putExtra(VBeam.EXTRA_VBEAM_PAYLOAD, result.payload);
+                    startActivity(resultIntent);
+                    finish();
+                } catch (Throwable t) {
+                    t.printStackTrace();
+                }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+                finish();
+            }
+        });
+    }
+}
diff --git a/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamManager.java b/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamManager.java
new file mode 100644
index 0000000..d6c008e
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamManager.java
@@ -0,0 +1,144 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.impl.google.services.beam;
+
+import android.app.Activity;
+import android.net.Uri;
+import android.nfc.NdefMessage;
+import android.nfc.NdefRecord;
+import android.nfc.NfcAdapter;
+import android.nfc.NfcEvent;
+import android.util.Log;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.security.interfaces.ECPublicKey;
+
+import io.v.android.v23.VBeam;
+import io.v.v23.V;
+import io.v.v23.context.VContext;
+import io.v.v23.naming.Endpoint;
+import io.v.v23.security.VSecurity;
+import io.v.v23.verror.VException;
+
+/**
+ * Internal implementation of {@link VBeam} for an activity.
+ */
+public class VBeamManager implements NfcAdapter.CreateNdefMessageCallback {
+
+    static final String EXTERNAL_DOMAIN = "io.v.android.vbeam";
+    static final String EXTERNAL_TYPE = "vbs";
+    private static final String EXTERNAL_PATH = "/" + EXTERNAL_DOMAIN + ":" + EXTERNAL_TYPE;
+    private static final String TAG = "VBeamManager";
+    private final VBeamServer server;
+    private final VContext context;
+    private final String packageName;
+
+    /**
+     * Key for the payload bytes in a VBeam intent.
+     */
+    public static final String EXTRA_VBEAM_PAYLOAD = "io.v.intent.vbeam.payload";
+
+    /**
+     * Starts the VBeam server and registers the activity to send NDEF messages.
+     * @param context
+     * @param activity
+     * @param creator
+     * @throws VException
+     */
+    public VBeamManager(VContext context, Activity activity, VBeam.IntentCreator creator)
+            throws VException {
+        this.server = new VBeamServer(creator);
+        this.packageName = activity.getApplicationContext().getPackageName();
+        this.context = V.withNewServer(
+                context, "", this.server, VSecurity.newAllowEveryoneAuthorizer());
+    }
+
+    @Override
+    public NdefMessage createNdefMessage(NfcEvent event) {
+        try {
+            String requestID = server.newRequest();
+
+            byte[] payload;
+            try {
+                Data data = new Data();
+                data.secret = requestID;
+                data.key = V.getPrincipal(context).publicKey();
+                data.name = getEndpointName();
+                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                ObjectOutputStream oos = new ObjectOutputStream(bos);
+                oos.writeObject(data);
+                oos.flush();
+                payload = bos.toByteArray();
+                oos.close();
+                bos.close();
+            } catch (IOException e) {
+                Log.e(TAG, "unable to encode ndef message", e);
+                return null;
+            }
+            return new NdefMessage(
+                    new NdefRecord[]{
+                            NdefRecord.createExternal(EXTERNAL_DOMAIN, EXTERNAL_TYPE, payload),
+                            NdefRecord.createApplicationRecord(packageName)
+                    }
+            );
+        } catch (Throwable t) {
+            Log.e(TAG, "createNdefMessage failed", t);
+            throw t;
+        }
+    }
+
+    static Data decodeMessage(NdefMessage m) {
+        for (NdefRecord r : m.getRecords()) {
+            Uri uri = r.toUri();
+            if (uri == null || !EXTERNAL_PATH.equals(uri.getPath())) {
+                if (Log.isLoggable(TAG, Log.DEBUG)) {
+                    StringBuilder description = new StringBuilder("ignoring ");
+                    if (uri == null) {
+                        description.append(r);
+                    } else {
+                        description.append(uri.getPath());
+                        description.append(" != ");
+                        description.append(EXTERNAL_PATH);
+                    }
+                    Log.d(TAG, description.toString());
+                }
+                continue;
+            }
+            byte[] payload = r.getPayload();
+            if (payload != null) {
+                ByteArrayInputStream bis = new ByteArrayInputStream(payload);
+                ObjectInputStream ois = null;
+                try {
+                    ois = new ObjectInputStream(bis);
+                    Object d = ois.readObject();
+                    if (d != null && d instanceof Data) {
+                        return (Data)d;
+                    }
+                } catch (IOException e) {
+                    Log.e(TAG, "decodeMessage", e);
+                } catch (ClassNotFoundException e) {
+                    Log.e(TAG, "decodeMessage", e);
+                }
+            }
+        }
+        return null;
+    }
+
+    private String getEndpointName() {
+        Endpoint[] endpoints = V.getServer(context).getStatus().getEndpoints();
+        return endpoints[0].name();
+    }
+
+    static class Data implements Serializable {
+        String name;
+        String secret;
+        ECPublicKey key;
+    }
+}
diff --git a/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamServer.java b/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamServer.java
new file mode 100644
index 0000000..3ace363
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/impl/google/services/beam/VBeamServer.java
@@ -0,0 +1,84 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.impl.google.services.beam;
+
+import android.util.Pair;
+
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import io.v.android.v23.VBeam;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.ServerCall;
+import io.v.v23.verror.VException;
+
+class VBeamServer implements IntentBeamerServer {
+    private static final long EXPIRATION_MS = 60000;
+
+    private final Map<String, Long> requestMap = new LinkedHashMap<>();
+    private final VBeam.IntentCreator callback;
+
+    public VBeamServer(VBeam.IntentCreator creator) throws VException {
+        this.callback = creator;
+    }
+
+    @Override
+    public synchronized ListenableFuture<GetIntentOut> getIntent(
+            VContext ctx, ServerCall call, String secret) {
+        evictStaleRequests();
+        if (requestMap.remove(secret) != null) {
+            try {
+                return Futures.transform(
+                        callback.createIntent(ctx, call),
+                        new AsyncFunction<Pair<String, byte[]>, GetIntentOut>() {
+
+                        @Override
+                        public ListenableFuture<GetIntentOut> apply(Pair<String, byte[]> input)
+                                throws Exception {
+                            return convertIntent(input);
+                        }
+                });
+            } catch (Throwable t) {
+                return Futures.immediateFailedFuture(t);
+            }
+        }
+        return Futures.immediateFailedFuture(new VException("Bad request"));
+    }
+
+    private static ListenableFuture<GetIntentOut> convertIntent(Pair<String, byte[]> intent) {
+        GetIntentOut out = new GetIntentOut();
+        out.intentUri = intent.first;
+        out.payload = intent.second;
+        return Futures.immediateFuture(out);
+    }
+
+    private synchronized void evictStaleRequests() {
+        long now = System.currentTimeMillis();
+        for (Iterator<Long> it = requestMap.values().iterator(); it.hasNext();) {
+            long l = it.next();
+            if (l > now || l < now - EXPIRATION_MS) {
+                it.remove();
+            } else {
+                // LinkedHashMap is sorted by insertion order, so oldest entry is first.
+                break;
+            }
+        }
+    }
+
+    synchronized String newRequest() {
+        evictStaleRequests();
+        String secret = UUID.randomUUID().toString();
+        synchronized(requestMap) {
+            requestMap.put(secret, System.currentTimeMillis());
+        }
+        return secret;
+    }
+}
diff --git a/android-lib/src/main/java/io/v/android/impl/google/services/beam/beamer.vdl b/android-lib/src/main/java/io/v/android/impl/google/services/beam/beamer.vdl
new file mode 100644
index 0000000..a61f8cd
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/impl/google/services/beam/beamer.vdl
@@ -0,0 +1,9 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package beam
+
+type IntentBeamer interface {
+  GetIntent(secret string) (intentUri string, payload []byte | error)
+}
\ No newline at end of file
diff --git a/android-lib/src/main/java/io/v/android/v23/VBeam.java b/android-lib/src/main/java/io/v/android/v23/VBeam.java
new file mode 100644
index 0000000..41ee7b6
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/v23/VBeam.java
@@ -0,0 +1,92 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.v23;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.nfc.NfcAdapter;
+import android.util.Pair;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+import io.v.android.impl.google.services.beam.VBeamManager;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.ServerCall;
+import io.v.v23.security.Call;
+import io.v.v23.verror.VException;
+
+/**
+ * Enables sending authenticated data over Android Beam.
+ * <p>
+ * To support Beam in an activity you register an {@link io.v.android.v23.VBeam.IntentCreator}.
+ * When the user initiates an NFC tap, the framework will call
+ * {@link io.v.android.v23.VBeam.IntentCreator#createIntent(VContext, ServerCall)}. You should
+ * return an intent encapsulating the data you wish to share.
+ * <p>
+ * Internally this starts a Vanadium service on this phone. After tapping the app will start on
+ * the destination phone and contact the sender. You may then inspect the credentials the app
+ * is using on the destination phone and decide what data to send. For example, you may
+ * add their blessing to an ACL and then send the name of the object you are trying to share.
+ * <p>
+ * Beaming will fail if the app is in the foreground on both phones. The destination
+ * phone should not have the app open.
+ * <p>
+ * If the app is not installed on the destination phone, it will open in the Play store.
+ */
+public class VBeam {
+    private final static String TAG = "VBeam";
+
+    /**
+     * A callback to be invoked when Beam has been inititaed to another device.
+     */
+    public interface IntentCreator {
+        /**
+         * Create the intent to transfer to the destination phone.
+         * <p>
+         * This runs on the sender phone. The credentials for the receiver phone are available
+         * in {@code call}. For example you can use
+         * {@link io.v.v23.security.VSecurity#getRemoteBlessingNames(VContext, Call)} to find the
+         * receiver's blessings.
+         * <p>
+         * You should return an intent URI (as returned by {@link Intent#toUri(int)}), and
+         * optionally a byte array payload. This intent will be started on the receiver phone.
+         */
+        ListenableFuture<Pair<String, byte[]>> createIntent(VContext context, ServerCall call);
+    }
+
+    /**
+     * Set a callback that dynamically generates an Intent to send using Android Beam.
+     * <p>
+     * You should call this method during your Activity's onCreate(). You should cancel the context
+     * in your Activity's onDestroy(), but not before.
+     * <p>
+     * Do not mix calls to VBeam and NfcAdapter for the same activity.
+     */
+    public static boolean setBeamIntentCallback(VContext context,
+                                                Activity activity,
+                                                IntentCreator creator) throws VException {
+        NfcAdapter nfc = NfcAdapter.getDefaultAdapter(activity);
+        if (nfc == null)
+            return false;
+        if (creator == null) {
+            nfc.setNdefPushMessageCallback(null, activity);
+            return true;
+        }
+
+        final VBeamManager vBeamManager = new VBeamManager(context, activity, creator);
+        nfc.setNdefPushMessageCallback(vBeamManager, activity);
+        return true;
+    }
+
+    private VBeam() { }  // static
+
+    /**
+     * Returns the {@code byte[]} payload from an intent sent using VBeam.
+     * Call this on the receiving device to retrieve your payload.
+     */
+    public static byte[] getBeamPayload(Intent intent) {
+        return intent.getByteArrayExtra(VBeamManager.EXTRA_VBEAM_PAYLOAD);
+    }
+}